plink: updated to revision 10170 of putty

1 files changed, 1486 insertions, 1479 deletions

diff --git a/tools/plink/tree234.c b/tools/plink/tree234.c
index 4e2da9dd6..f1c0c2edb 100644
--- a/tools/plink/tree234.c
+++ b/tools/plink/tree234.c
@@ -1,1479 +1,1486 @@
-/*

- * tree234.c: reasonably generic counted 2-3-4 tree routines.

- * 

- * This file is copyright 1999-2001 Simon Tatham.

- * 

- * Permission is hereby granted, free of charge, to any person

- * obtaining a copy of this software and associated documentation

- * files (the "Software"), to deal in the Software without

- * restriction, including without limitation the rights to use,

- * copy, modify, merge, publish, distribute, sublicense, and/or

- * sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following

- * conditions:

- * 

- * The above copyright notice and this permission notice shall be

- * included in all copies or substantial portions of the Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

- * NONINFRINGEMENT.  IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR

- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

- * SOFTWARE.

- */

-

-#include <stdio.h>

-#include <stdlib.h>

-#include <assert.h>

-

-#include "puttymem.h"

-#include "tree234.h"

-

-#ifdef TEST

-#define LOG(x) (printf x)

-#else

-#define LOG(x)

-#endif

-

-typedef struct node234_Tag node234;

-

-struct tree234_Tag {

-    node234 *root;

-    cmpfn234 cmp;

-};

-

-struct node234_Tag {

-    node234 *parent;

-    node234 *kids[4];

-    int counts[4];

-    void *elems[3];

-};

-

-/*

- * Create a 2-3-4 tree.

- */

-tree234 *newtree234(cmpfn234 cmp)

-{

-    tree234 *ret = snew(tree234);

-    LOG(("created tree %p\n", ret));

-    ret->root = NULL;

-    ret->cmp = cmp;

-    return ret;

-}

-

-/*

- * Free a 2-3-4 tree (not including freeing the elements).

- */

-static void freenode234(node234 * n)

-{

-    if (!n)

-	return;

-    freenode234(n->kids[0]);

-    freenode234(n->kids[1]);

-    freenode234(n->kids[2]);

-    freenode234(n->kids[3]);

-    sfree(n);

-}

-

-void freetree234(tree234 * t)

-{

-    freenode234(t->root);

-    sfree(t);

-}

-

-/*

- * Internal function to count a node.

- */

-static int countnode234(node234 * n)

-{

-    int count = 0;

-    int i;

-    if (!n)

-	return 0;

-    for (i = 0; i < 4; i++)

-	count += n->counts[i];

-    for (i = 0; i < 3; i++)

-	if (n->elems[i])

-	    count++;

-    return count;

-}

-

-/*

- * Count the elements in a tree.

- */

-int count234(tree234 * t)

-{

-    if (t->root)

-	return countnode234(t->root);

-    else

-	return 0;

-}

-

-/*

- * Add an element e to a 2-3-4 tree t. Returns e on success, or if

- * an existing element compares equal, returns that.

- */

-static void *add234_internal(tree234 * t, void *e, int index)

-{

-    node234 *n, **np, *left, *right;

-    void *orig_e = e;

-    int c, lcount, rcount;

-

-    LOG(("adding node %p to tree %p\n", e, t));

-    if (t->root == NULL) {

-	t->root = snew(node234);

-	t->root->elems[1] = t->root->elems[2] = NULL;

-	t->root->kids[0] = t->root->kids[1] = NULL;

-	t->root->kids[2] = t->root->kids[3] = NULL;

-	t->root->counts[0] = t->root->counts[1] = 0;

-	t->root->counts[2] = t->root->counts[3] = 0;

-	t->root->parent = NULL;

-	t->root->elems[0] = e;

-	LOG(("  created root %p\n", t->root));

-	return orig_e;

-    }

-

-    n = NULL; /* placate gcc; will always be set below since t->root != NULL */

-    np = &t->root;

-    while (*np) {

-	int childnum;

-	n = *np;

-	LOG(("  node %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d\n",

-	     n,

-	     n->kids[0], n->counts[0], n->elems[0],

-	     n->kids[1], n->counts[1], n->elems[1],

-	     n->kids[2], n->counts[2], n->elems[2],

-	     n->kids[3], n->counts[3]));

-	if (index >= 0) {

-	    if (!n->kids[0]) {

-		/*

-		 * Leaf node. We want to insert at kid position

-		 * equal to the index:

-		 * 

-		 *   0 A 1 B 2 C 3

-		 */

-		childnum = index;

-	    } else {

-		/*

-		 * Internal node. We always descend through it (add

-		 * always starts at the bottom, never in the

-		 * middle).

-		 */

-		do {		       /* this is a do ... while (0) to allow `break' */

-		    if (index <= n->counts[0]) {

-			childnum = 0;

-			break;

-		    }

-		    index -= n->counts[0] + 1;

-		    if (index <= n->counts[1]) {

-			childnum = 1;

-			break;

-		    }

-		    index -= n->counts[1] + 1;

-		    if (index <= n->counts[2]) {

-			childnum = 2;

-			break;

-		    }

-		    index -= n->counts[2] + 1;

-		    if (index <= n->counts[3]) {

-			childnum = 3;

-			break;

-		    }

-		    return NULL;       /* error: index out of range */

-		} while (0);

-	    }

-	} else {

-	    if ((c = t->cmp(e, n->elems[0])) < 0)

-		childnum = 0;

-	    else if (c == 0)

-		return n->elems[0];    /* already exists */

-	    else if (n->elems[1] == NULL

-		     || (c = t->cmp(e, n->elems[1])) < 0) childnum = 1;

-	    else if (c == 0)

-		return n->elems[1];    /* already exists */

-	    else if (n->elems[2] == NULL

-		     || (c = t->cmp(e, n->elems[2])) < 0) childnum = 2;

-	    else if (c == 0)

-		return n->elems[2];    /* already exists */

-	    else

-		childnum = 3;

-	}

-	np = &n->kids[childnum];

-	LOG(("  moving to child %d (%p)\n", childnum, *np));

-    }

-

-    /*

-     * We need to insert the new element in n at position np.

-     */

-    left = NULL;

-    lcount = 0;

-    right = NULL;

-    rcount = 0;

-    while (n) {

-	LOG(("  at %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d\n",

-	     n,

-	     n->kids[0], n->counts[0], n->elems[0],

-	     n->kids[1], n->counts[1], n->elems[1],

-	     n->kids[2], n->counts[2], n->elems[2],

-	     n->kids[3], n->counts[3]));

-	LOG(("  need to insert %p/%d [%p] %p/%d at position %d\n",

-	     left, lcount, e, right, rcount, np - n->kids));

-	if (n->elems[1] == NULL) {

-	    /*

-	     * Insert in a 2-node; simple.

-	     */

-	    if (np == &n->kids[0]) {

-		LOG(("  inserting on left of 2-node\n"));

-		n->kids[2] = n->kids[1];

-		n->counts[2] = n->counts[1];

-		n->elems[1] = n->elems[0];

-		n->kids[1] = right;

-		n->counts[1] = rcount;

-		n->elems[0] = e;

-		n->kids[0] = left;

-		n->counts[0] = lcount;

-	    } else {		       /* np == &n->kids[1] */

-		LOG(("  inserting on right of 2-node\n"));

-		n->kids[2] = right;

-		n->counts[2] = rcount;

-		n->elems[1] = e;

-		n->kids[1] = left;

-		n->counts[1] = lcount;

-	    }

-	    if (n->kids[0])

-		n->kids[0]->parent = n;

-	    if (n->kids[1])

-		n->kids[1]->parent = n;

-	    if (n->kids[2])

-		n->kids[2]->parent = n;

-	    LOG(("  done\n"));

-	    break;

-	} else if (n->elems[2] == NULL) {

-	    /*

-	     * Insert in a 3-node; simple.

-	     */

-	    if (np == &n->kids[0]) {

-		LOG(("  inserting on left of 3-node\n"));

-		n->kids[3] = n->kids[2];

-		n->counts[3] = n->counts[2];

-		n->elems[2] = n->elems[1];

-		n->kids[2] = n->kids[1];

-		n->counts[2] = n->counts[1];

-		n->elems[1] = n->elems[0];

-		n->kids[1] = right;

-		n->counts[1] = rcount;

-		n->elems[0] = e;

-		n->kids[0] = left;

-		n->counts[0] = lcount;

-	    } else if (np == &n->kids[1]) {

-		LOG(("  inserting in middle of 3-node\n"));

-		n->kids[3] = n->kids[2];

-		n->counts[3] = n->counts[2];

-		n->elems[2] = n->elems[1];

-		n->kids[2] = right;

-		n->counts[2] = rcount;

-		n->elems[1] = e;

-		n->kids[1] = left;

-		n->counts[1] = lcount;

-	    } else {		       /* np == &n->kids[2] */

-		LOG(("  inserting on right of 3-node\n"));

-		n->kids[3] = right;

-		n->counts[3] = rcount;

-		n->elems[2] = e;

-		n->kids[2] = left;

-		n->counts[2] = lcount;

-	    }

-	    if (n->kids[0])

-		n->kids[0]->parent = n;

-	    if (n->kids[1])

-		n->kids[1]->parent = n;

-	    if (n->kids[2])

-		n->kids[2]->parent = n;

-	    if (n->kids[3])

-		n->kids[3]->parent = n;

-	    LOG(("  done\n"));

-	    break;

-	} else {

-	    node234 *m = snew(node234);

-	    m->parent = n->parent;

-	    LOG(("  splitting a 4-node; created new node %p\n", m));

-	    /*

-	     * Insert in a 4-node; split into a 2-node and a

-	     * 3-node, and move focus up a level.

-	     * 

-	     * I don't think it matters which way round we put the

-	     * 2 and the 3. For simplicity, we'll put the 3 first

-	     * always.

-	     */

-	    if (np == &n->kids[0]) {

-		m->kids[0] = left;

-		m->counts[0] = lcount;

-		m->elems[0] = e;

-		m->kids[1] = right;

-		m->counts[1] = rcount;

-		m->elems[1] = n->elems[0];

-		m->kids[2] = n->kids[1];

-		m->counts[2] = n->counts[1];

-		e = n->elems[1];

-		n->kids[0] = n->kids[2];

-		n->counts[0] = n->counts[2];

-		n->elems[0] = n->elems[2];

-		n->kids[1] = n->kids[3];

-		n->counts[1] = n->counts[3];

-	    } else if (np == &n->kids[1]) {

-		m->kids[0] = n->kids[0];

-		m->counts[0] = n->counts[0];

-		m->elems[0] = n->elems[0];

-		m->kids[1] = left;

-		m->counts[1] = lcount;

-		m->elems[1] = e;

-		m->kids[2] = right;

-		m->counts[2] = rcount;

-		e = n->elems[1];

-		n->kids[0] = n->kids[2];

-		n->counts[0] = n->counts[2];

-		n->elems[0] = n->elems[2];

-		n->kids[1] = n->kids[3];

-		n->counts[1] = n->counts[3];

-	    } else if (np == &n->kids[2]) {

-		m->kids[0] = n->kids[0];

-		m->counts[0] = n->counts[0];

-		m->elems[0] = n->elems[0];

-		m->kids[1] = n->kids[1];

-		m->counts[1] = n->counts[1];

-		m->elems[1] = n->elems[1];

-		m->kids[2] = left;

-		m->counts[2] = lcount;

-		/* e = e; */

-		n->kids[0] = right;

-		n->counts[0] = rcount;

-		n->elems[0] = n->elems[2];

-		n->kids[1] = n->kids[3];

-		n->counts[1] = n->counts[3];

-	    } else {		       /* np == &n->kids[3] */

-		m->kids[0] = n->kids[0];

-		m->counts[0] = n->counts[0];

-		m->elems[0] = n->elems[0];

-		m->kids[1] = n->kids[1];

-		m->counts[1] = n->counts[1];

-		m->elems[1] = n->elems[1];

-		m->kids[2] = n->kids[2];

-		m->counts[2] = n->counts[2];

-		n->kids[0] = left;

-		n->counts[0] = lcount;

-		n->elems[0] = e;

-		n->kids[1] = right;

-		n->counts[1] = rcount;

-		e = n->elems[2];

-	    }

-	    m->kids[3] = n->kids[3] = n->kids[2] = NULL;

-	    m->counts[3] = n->counts[3] = n->counts[2] = 0;

-	    m->elems[2] = n->elems[2] = n->elems[1] = NULL;

-	    if (m->kids[0])

-		m->kids[0]->parent = m;

-	    if (m->kids[1])

-		m->kids[1]->parent = m;

-	    if (m->kids[2])

-		m->kids[2]->parent = m;

-	    if (n->kids[0])

-		n->kids[0]->parent = n;

-	    if (n->kids[1])

-		n->kids[1]->parent = n;

-	    LOG(("  left (%p): %p/%d [%p] %p/%d [%p] %p/%d\n", m,

-		 m->kids[0], m->counts[0], m->elems[0],

-		 m->kids[1], m->counts[1], m->elems[1],

-		 m->kids[2], m->counts[2]));

-	    LOG(("  right (%p): %p/%d [%p] %p/%d\n", n,

-		 n->kids[0], n->counts[0], n->elems[0],

-		 n->kids[1], n->counts[1]));

-	    left = m;

-	    lcount = countnode234(left);

-	    right = n;

-	    rcount = countnode234(right);

-	}

-	if (n->parent)

-	    np = (n->parent->kids[0] == n ? &n->parent->kids[0] :

-		  n->parent->kids[1] == n ? &n->parent->kids[1] :

-		  n->parent->kids[2] == n ? &n->parent->kids[2] :

-		  &n->parent->kids[3]);

-	n = n->parent;

-    }

-

-    /*

-     * If we've come out of here by `break', n will still be

-     * non-NULL and all we need to do is go back up the tree

-     * updating counts. If we've come here because n is NULL, we

-     * need to create a new root for the tree because the old one

-     * has just split into two. */

-    if (n) {

-	while (n->parent) {

-	    int count = countnode234(n);

-	    int childnum;

-	    childnum = (n->parent->kids[0] == n ? 0 :

-			n->parent->kids[1] == n ? 1 :

-			n->parent->kids[2] == n ? 2 : 3);

-	    n->parent->counts[childnum] = count;

-	    n = n->parent;

-	}

-    } else {

-	LOG(("  root is overloaded, split into two\n"));

-	t->root = snew(node234);

-	t->root->kids[0] = left;

-	t->root->counts[0] = lcount;

-	t->root->elems[0] = e;

-	t->root->kids[1] = right;

-	t->root->counts[1] = rcount;

-	t->root->elems[1] = NULL;

-	t->root->kids[2] = NULL;

-	t->root->counts[2] = 0;

-	t->root->elems[2] = NULL;

-	t->root->kids[3] = NULL;

-	t->root->counts[3] = 0;

-	t->root->parent = NULL;

-	if (t->root->kids[0])

-	    t->root->kids[0]->parent = t->root;

-	if (t->root->kids[1])

-	    t->root->kids[1]->parent = t->root;

-	LOG(("  new root is %p/%d [%p] %p/%d\n",

-	     t->root->kids[0], t->root->counts[0],

-	     t->root->elems[0], t->root->kids[1], t->root->counts[1]));

-    }

-

-    return orig_e;

-}

-

-void *add234(tree234 * t, void *e)

-{

-    if (!t->cmp)		       /* tree is unsorted */

-	return NULL;

-

-    return add234_internal(t, e, -1);

-}

-void *addpos234(tree234 * t, void *e, int index)

-{

-    if (index < 0 ||		       /* index out of range */

-	t->cmp)			       /* tree is sorted */

-	return NULL;		       /* return failure */

-

-    return add234_internal(t, e, index);	/* this checks the upper bound */

-}

-

-/*

- * Look up the element at a given numeric index in a 2-3-4 tree.

- * Returns NULL if the index is out of range.

- */

-void *index234(tree234 * t, int index)

-{

-    node234 *n;

-

-    if (!t->root)

-	return NULL;		       /* tree is empty */

-

-    if (index < 0 || index >= countnode234(t->root))

-	return NULL;		       /* out of range */

-

-    n = t->root;

-

-    while (n) {

-	if (index < n->counts[0])

-	    n = n->kids[0];

-	else if (index -= n->counts[0] + 1, index < 0)

-	    return n->elems[0];

-	else if (index < n->counts[1])

-	    n = n->kids[1];

-	else if (index -= n->counts[1] + 1, index < 0)

-	    return n->elems[1];

-	else if (index < n->counts[2])

-	    n = n->kids[2];

-	else if (index -= n->counts[2] + 1, index < 0)

-	    return n->elems[2];

-	else

-	    n = n->kids[3];

-    }

-

-    /* We shouldn't ever get here. I wonder how we did. */

-    return NULL;

-}

-

-/*

- * Find an element e in a sorted 2-3-4 tree t. Returns NULL if not

- * found. e is always passed as the first argument to cmp, so cmp

- * can be an asymmetric function if desired. cmp can also be passed

- * as NULL, in which case the compare function from the tree proper

- * will be used.

- */

-void *findrelpos234(tree234 * t, void *e, cmpfn234 cmp,

-		    int relation, int *index)

-{

-    node234 *n;

-    void *ret;

-    int c;

-    int idx, ecount, kcount, cmpret;

-

-    if (t->root == NULL)

-	return NULL;

-

-    if (cmp == NULL)

-	cmp = t->cmp;

-

-    n = t->root;

-    /*

-     * Attempt to find the element itself.

-     */

-    idx = 0;

-    ecount = -1;

-    /*

-     * Prepare a fake `cmp' result if e is NULL.

-     */

-    cmpret = 0;

-    if (e == NULL) {

-	assert(relation == REL234_LT || relation == REL234_GT);

-	if (relation == REL234_LT)

-	    cmpret = +1;	       /* e is a max: always greater */

-	else if (relation == REL234_GT)

-	    cmpret = -1;	       /* e is a min: always smaller */

-    }

-    while (1) {

-	for (kcount = 0; kcount < 4; kcount++) {

-	    if (kcount >= 3 || n->elems[kcount] == NULL ||

-		(c = cmpret ? cmpret : cmp(e, n->elems[kcount])) < 0) {

-		break;

-	    }

-	    if (n->kids[kcount])

-		idx += n->counts[kcount];

-	    if (c == 0) {

-		ecount = kcount;

-		break;

-	    }

-	    idx++;

-	}

-	if (ecount >= 0)

-	    break;

-	if (n->kids[kcount])

-	    n = n->kids[kcount];

-	else

-	    break;

-    }

-

-    if (ecount >= 0) {

-	/*

-	 * We have found the element we're looking for. It's

-	 * n->elems[ecount], at tree index idx. If our search

-	 * relation is EQ, LE or GE we can now go home.

-	 */

-	if (relation != REL234_LT && relation != REL234_GT) {

-	    if (index)

-		*index = idx;

-	    return n->elems[ecount];

-	}

-

-	/*

-	 * Otherwise, we'll do an indexed lookup for the previous

-	 * or next element. (It would be perfectly possible to

-	 * implement these search types in a non-counted tree by

-	 * going back up from where we are, but far more fiddly.)

-	 */

-	if (relation == REL234_LT)

-	    idx--;

-	else

-	    idx++;

-    } else {

-	/*

-	 * We've found our way to the bottom of the tree and we

-	 * know where we would insert this node if we wanted to:

-	 * we'd put it in in place of the (empty) subtree

-	 * n->kids[kcount], and it would have index idx

-	 * 

-	 * But the actual element isn't there. So if our search

-	 * relation is EQ, we're doomed.

-	 */

-	if (relation == REL234_EQ)

-	    return NULL;

-

-	/*

-	 * Otherwise, we must do an index lookup for index idx-1

-	 * (if we're going left - LE or LT) or index idx (if we're

-	 * going right - GE or GT).

-	 */

-	if (relation == REL234_LT || relation == REL234_LE) {

-	    idx--;

-	}

-    }

-

-    /*

-     * We know the index of the element we want; just call index234

-     * to do the rest. This will return NULL if the index is out of

-     * bounds, which is exactly what we want.

-     */

-    ret = index234(t, idx);

-    if (ret && index)

-	*index = idx;

-    return ret;

-}

-void *find234(tree234 * t, void *e, cmpfn234 cmp)

-{

-    return findrelpos234(t, e, cmp, REL234_EQ, NULL);

-}

-void *findrel234(tree234 * t, void *e, cmpfn234 cmp, int relation)

-{

-    return findrelpos234(t, e, cmp, relation, NULL);

-}

-void *findpos234(tree234 * t, void *e, cmpfn234 cmp, int *index)

-{

-    return findrelpos234(t, e, cmp, REL234_EQ, index);

-}

-

-/*

- * Delete an element e in a 2-3-4 tree. Does not free the element,

- * merely removes all links to it from the tree nodes.

- */

-static void *delpos234_internal(tree234 * t, int index)

-{

-    node234 *n;

-    void *retval;

-    int ei = -1;

-

-    retval = 0;

-

-    n = t->root;

-    LOG(("deleting item %d from tree %p\n", index, t));

-    while (1) {

-	while (n) {

-	    int ki;

-	    node234 *sub;

-

-	    LOG(

-		("  node %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d index=%d\n",

-		 n, n->kids[0], n->counts[0], n->elems[0], n->kids[1],

-		 n->counts[1], n->elems[1], n->kids[2], n->counts[2],

-		 n->elems[2], n->kids[3], n->counts[3], index));

-	    if (index < n->counts[0]) {

-		ki = 0;

-	    } else if (index -= n->counts[0] + 1, index < 0) {

-		ei = 0;

-		break;

-	    } else if (index < n->counts[1]) {

-		ki = 1;

-	    } else if (index -= n->counts[1] + 1, index < 0) {

-		ei = 1;

-		break;

-	    } else if (index < n->counts[2]) {

-		ki = 2;

-	    } else if (index -= n->counts[2] + 1, index < 0) {

-		ei = 2;

-		break;

-	    } else {

-		ki = 3;

-	    }

-	    /*

-	     * Recurse down to subtree ki. If it has only one element,

-	     * we have to do some transformation to start with.

-	     */

-	    LOG(("  moving to subtree %d\n", ki));

-	    sub = n->kids[ki];

-	    if (!sub->elems[1]) {

-		LOG(("  subtree has only one element!\n", ki));

-		if (ki > 0 && n->kids[ki - 1]->elems[1]) {

-		    /*

-		     * Case 3a, left-handed variant. Child ki has

-		     * only one element, but child ki-1 has two or

-		     * more. So we need to move a subtree from ki-1

-		     * to ki.

-		     * 

-		     *                . C .                     . B .

-		     *               /     \     ->            /     \

-		     * [more] a A b B c   d D e      [more] a A b   c C d D e

-		     */

-		    node234 *sib = n->kids[ki - 1];

-		    int lastelem = (sib->elems[2] ? 2 :

-				    sib->elems[1] ? 1 : 0);

-		    sub->kids[2] = sub->kids[1];

-		    sub->counts[2] = sub->counts[1];

-		    sub->elems[1] = sub->elems[0];

-		    sub->kids[1] = sub->kids[0];

-		    sub->counts[1] = sub->counts[0];

-		    sub->elems[0] = n->elems[ki - 1];

-		    sub->kids[0] = sib->kids[lastelem + 1];

-		    sub->counts[0] = sib->counts[lastelem + 1];

-		    if (sub->kids[0])

-			sub->kids[0]->parent = sub;

-		    n->elems[ki - 1] = sib->elems[lastelem];

-		    sib->kids[lastelem + 1] = NULL;

-		    sib->counts[lastelem + 1] = 0;

-		    sib->elems[lastelem] = NULL;

-		    n->counts[ki] = countnode234(sub);

-		    LOG(("  case 3a left\n"));

-		    LOG(

-			("  index and left subtree count before adjustment: %d, %d\n",

-			 index, n->counts[ki - 1]));

-		    index += n->counts[ki - 1];

-		    n->counts[ki - 1] = countnode234(sib);

-		    index -= n->counts[ki - 1];

-		    LOG(

-			("  index and left subtree count after adjustment: %d, %d\n",

-			 index, n->counts[ki - 1]));

-		} else if (ki < 3 && n->kids[ki + 1]

-			   && n->kids[ki + 1]->elems[1]) {

-		    /*

-		     * Case 3a, right-handed variant. ki has only

-		     * one element but ki+1 has two or more. Move a

-		     * subtree from ki+1 to ki.

-		     * 

-		     *      . B .                             . C .

-		     *     /     \                ->         /     \

-		     *  a A b   c C d D e [more]      a A b B c   d D e [more]

-		     */

-		    node234 *sib = n->kids[ki + 1];

-		    int j;

-		    sub->elems[1] = n->elems[ki];

-		    sub->kids[2] = sib->kids[0];

-		    sub->counts[2] = sib->counts[0];

-		    if (sub->kids[2])

-			sub->kids[2]->parent = sub;

-		    n->elems[ki] = sib->elems[0];

-		    sib->kids[0] = sib->kids[1];

-		    sib->counts[0] = sib->counts[1];

-		    for (j = 0; j < 2 && sib->elems[j + 1]; j++) {

-			sib->kids[j + 1] = sib->kids[j + 2];

-			sib->counts[j + 1] = sib->counts[j + 2];

-			sib->elems[j] = sib->elems[j + 1];

-		    }

-		    sib->kids[j + 1] = NULL;

-		    sib->counts[j + 1] = 0;

-		    sib->elems[j] = NULL;

-		    n->counts[ki] = countnode234(sub);

-		    n->counts[ki + 1] = countnode234(sib);

-		    LOG(("  case 3a right\n"));

-		} else {

-		    /*

-		     * Case 3b. ki has only one element, and has no

-		     * neighbour with more than one. So pick a

-		     * neighbour and merge it with ki, taking an

-		     * element down from n to go in the middle.

-		     *

-		     *      . B .                .

-		     *     /     \     ->        |

-		     *  a A b   c C d      a A b B c C d

-		     * 

-		     * (Since at all points we have avoided

-		     * descending to a node with only one element,

-		     * we can be sure that n is not reduced to

-		     * nothingness by this move, _unless_ it was

-		     * the very first node, ie the root of the

-		     * tree. In that case we remove the now-empty

-		     * root and replace it with its single large

-		     * child as shown.)

-		     */

-		    node234 *sib;

-		    int j;

-

-		    if (ki > 0) {

-			ki--;

-			index += n->counts[ki] + 1;

-		    }

-		    sib = n->kids[ki];

-		    sub = n->kids[ki + 1];

-

-		    sub->kids[3] = sub->kids[1];

-		    sub->counts[3] = sub->counts[1];

-		    sub->elems[2] = sub->elems[0];

-		    sub->kids[2] = sub->kids[0];

-		    sub->counts[2] = sub->counts[0];

-		    sub->elems[1] = n->elems[ki];

-		    sub->kids[1] = sib->kids[1];

-		    sub->counts[1] = sib->counts[1];

-		    if (sub->kids[1])

-			sub->kids[1]->parent = sub;

-		    sub->elems[0] = sib->elems[0];

-		    sub->kids[0] = sib->kids[0];

-		    sub->counts[0] = sib->counts[0];

-		    if (sub->kids[0])

-			sub->kids[0]->parent = sub;

-

-		    n->counts[ki + 1] = countnode234(sub);

-

-		    sfree(sib);

-

-		    /*

-		     * That's built the big node in sub. Now we

-		     * need to remove the reference to sib in n.

-		     */

-		    for (j = ki; j < 3 && n->kids[j + 1]; j++) {

-			n->kids[j] = n->kids[j + 1];

-			n->counts[j] = n->counts[j + 1];

-			n->elems[j] = j < 2 ? n->elems[j + 1] : NULL;

-		    }

-		    n->kids[j] = NULL;

-		    n->counts[j] = 0;

-		    if (j < 3)

-			n->elems[j] = NULL;

-		    LOG(("  case 3b ki=%d\n", ki));

-

-		    if (!n->elems[0]) {

-			/*

-			 * The root is empty and needs to be

-			 * removed.

-			 */

-			LOG(("  shifting root!\n"));

-			t->root = sub;

-			sub->parent = NULL;

-			sfree(n);

-		    }

-		}

-	    }

-	    n = sub;

-	}

-	if (!retval)

-	    retval = n->elems[ei];

-

-	if (ei == -1)

-	    return NULL;	       /* although this shouldn't happen */

-

-	/*

-	 * Treat special case: this is the one remaining item in

-	 * the tree. n is the tree root (no parent), has one

-	 * element (no elems[1]), and has no kids (no kids[0]).

-	 */

-	if (!n->parent && !n->elems[1] && !n->kids[0]) {

-	    LOG(("  removed last element in tree\n"));

-	    sfree(n);

-	    t->root = NULL;

-	    return retval;

-	}

-

-	/*

-	 * Now we have the element we want, as n->elems[ei], and we

-	 * have also arranged for that element not to be the only

-	 * one in its node. So...

-	 */

-

-	if (!n->kids[0] && n->elems[1]) {

-	    /*

-	     * Case 1. n is a leaf node with more than one element,

-	     * so it's _really easy_. Just delete the thing and

-	     * we're done.

-	     */

-	    int i;

-	    LOG(("  case 1\n"));

-	    for (i = ei; i < 2 && n->elems[i + 1]; i++)

-		n->elems[i] = n->elems[i + 1];

-	    n->elems[i] = NULL;

-	    /*

-	     * Having done that to the leaf node, we now go back up

-	     * the tree fixing the counts.

-	     */

-	    while (n->parent) {

-		int childnum;

-		childnum = (n->parent->kids[0] == n ? 0 :

-			    n->parent->kids[1] == n ? 1 :

-			    n->parent->kids[2] == n ? 2 : 3);

-		n->parent->counts[childnum]--;

-		n = n->parent;

-	    }

-	    return retval;	       /* finished! */

-	} else if (n->kids[ei]->elems[1]) {

-	    /*

-	     * Case 2a. n is an internal node, and the root of the

-	     * subtree to the left of e has more than one element.

-	     * So find the predecessor p to e (ie the largest node

-	     * in that subtree), place it where e currently is, and

-	     * then start the deletion process over again on the

-	     * subtree with p as target.

-	     */

-	    node234 *m = n->kids[ei];

-	    void *target;

-	    LOG(("  case 2a\n"));

-	    while (m->kids[0]) {

-		m = (m->kids[3] ? m->kids[3] :

-		     m->kids[2] ? m->kids[2] :

-		     m->kids[1] ? m->kids[1] : m->kids[0]);

-	    }

-	    target = (m->elems[2] ? m->elems[2] :

-		      m->elems[1] ? m->elems[1] : m->elems[0]);

-	    n->elems[ei] = target;

-	    index = n->counts[ei] - 1;

-	    n = n->kids[ei];

-	} else if (n->kids[ei + 1]->elems[1]) {

-	    /*

-	     * Case 2b, symmetric to 2a but s/left/right/ and

-	     * s/predecessor/successor/. (And s/largest/smallest/).

-	     */

-	    node234 *m = n->kids[ei + 1];

-	    void *target;

-	    LOG(("  case 2b\n"));

-	    while (m->kids[0]) {

-		m = m->kids[0];

-	    }

-	    target = m->elems[0];

-	    n->elems[ei] = target;

-	    n = n->kids[ei + 1];

-	    index = 0;

-	} else {

-	    /*

-	     * Case 2c. n is an internal node, and the subtrees to

-	     * the left and right of e both have only one element.

-	     * So combine the two subnodes into a single big node

-	     * with their own elements on the left and right and e

-	     * in the middle, then restart the deletion process on

-	     * that subtree, with e still as target.

-	     */

-	    node234 *a = n->kids[ei], *b = n->kids[ei + 1];

-	    int j;

-

-	    LOG(("  case 2c\n"));

-	    a->elems[1] = n->elems[ei];

-	    a->kids[2] = b->kids[0];

-	    a->counts[2] = b->counts[0];

-	    if (a->kids[2])

-		a->kids[2]->parent = a;

-	    a->elems[2] = b->elems[0];

-	    a->kids[3] = b->kids[1];

-	    a->counts[3] = b->counts[1];

-	    if (a->kids[3])

-		a->kids[3]->parent = a;

-	    sfree(b);

-	    n->counts[ei] = countnode234(a);

-	    /*

-	     * That's built the big node in a, and destroyed b. Now

-	     * remove the reference to b (and e) in n.

-	     */

-	    for (j = ei; j < 2 && n->elems[j + 1]; j++) {

-		n->elems[j] = n->elems[j + 1];

-		n->kids[j + 1] = n->kids[j + 2];

-		n->counts[j + 1] = n->counts[j + 2];

-	    }

-	    n->elems[j] = NULL;

-	    n->kids[j + 1] = NULL;

-	    n->counts[j + 1] = 0;

-	    /*

-	     * It's possible, in this case, that we've just removed

-	     * the only element in the root of the tree. If so,

-	     * shift the root.

-	     */

-	    if (n->elems[0] == NULL) {

-		LOG(("  shifting root!\n"));

-		t->root = a;

-		a->parent = NULL;

-		sfree(n);

-	    }

-	    /*

-	     * Now go round the deletion process again, with n

-	     * pointing at the new big node and e still the same.

-	     */

-	    n = a;

-	    index = a->counts[0] + a->counts[1] + 1;

-	}

-    }

-}

-void *delpos234(tree234 * t, int index)

-{

-    if (index < 0 || index >= countnode234(t->root))

-	return NULL;

-    return delpos234_internal(t, index);

-}

-void *del234(tree234 * t, void *e)

-{

-    int index;

-    if (!findrelpos234(t, e, NULL, REL234_EQ, &index))

-	return NULL;		       /* it wasn't in there anyway */

-    return delpos234_internal(t, index);	/* it's there; delete it. */

-}

-

-#ifdef TEST

-

-/*

- * Test code for the 2-3-4 tree. This code maintains an alternative

- * representation of the data in the tree, in an array (using the

- * obvious and slow insert and delete functions). After each tree

- * operation, the verify() function is called, which ensures all

- * the tree properties are preserved:

- *  - node->child->parent always equals node

- *  - tree->root->parent always equals NULL

- *  - number of kids == 0 or number of elements + 1;

- *  - tree has the same depth everywhere

- *  - every node has at least one element

- *  - subtree element counts are accurate

- *  - any NULL kid pointer is accompanied by a zero count

- *  - in a sorted tree: ordering property between elements of a

- *    node and elements of its children is preserved

- * and also ensures the list represented by the tree is the same

- * list it should be. (This last check also doubly verifies the

- * ordering properties, because the `same list it should be' is by

- * definition correctly ordered. It also ensures all nodes are

- * distinct, because the enum functions would get caught in a loop

- * if not.)

- */

-

-#include <stdarg.h>

-

-/*

- * Error reporting function.

- */

-void error(char *fmt, ...)

-{

-    va_list ap;

-    printf("ERROR: ");

-    va_start(ap, fmt);

-    vfprintf(stdout, fmt, ap);

-    va_end(ap);

-    printf("\n");

-}

-

-/* The array representation of the data. */

-void **array;

-int arraylen, arraysize;

-cmpfn234 cmp;

-

-/* The tree representation of the same data. */

-tree234 *tree;

-

-typedef struct {

-    int treedepth;

-    int elemcount;

-} chkctx;

-

-int chknode(chkctx * ctx, int level, node234 * node,

-	    void *lowbound, void *highbound)

-{

-    int nkids, nelems;

-    int i;

-    int count;

-

-    /* Count the non-NULL kids. */

-    for (nkids = 0; nkids < 4 && node->kids[nkids]; nkids++);

-    /* Ensure no kids beyond the first NULL are non-NULL. */

-    for (i = nkids; i < 4; i++)

-	if (node->kids[i]) {

-	    error("node %p: nkids=%d but kids[%d] non-NULL",

-		  node, nkids, i);

-	} else if (node->counts[i]) {

-	    error("node %p: kids[%d] NULL but count[%d]=%d nonzero",

-		  node, i, i, node->counts[i]);

-	}

-

-    /* Count the non-NULL elements. */

-    for (nelems = 0; nelems < 3 && node->elems[nelems]; nelems++);

-    /* Ensure no elements beyond the first NULL are non-NULL. */

-    for (i = nelems; i < 3; i++)

-	if (node->elems[i]) {

-	    error("node %p: nelems=%d but elems[%d] non-NULL",

-		  node, nelems, i);

-	}

-

-    if (nkids == 0) {

-	/*

-	 * If nkids==0, this is a leaf node; verify that the tree

-	 * depth is the same everywhere.

-	 */

-	if (ctx->treedepth < 0)

-	    ctx->treedepth = level;    /* we didn't know the depth yet */

-	else if (ctx->treedepth != level)

-	    error("node %p: leaf at depth %d, previously seen depth %d",

-		  node, level, ctx->treedepth);

-    } else {

-	/*

-	 * If nkids != 0, then it should be nelems+1, unless nelems

-	 * is 0 in which case nkids should also be 0 (and so we

-	 * shouldn't be in this condition at all).

-	 */

-	int shouldkids = (nelems ? nelems + 1 : 0);

-	if (nkids != shouldkids) {

-	    error("node %p: %d elems should mean %d kids but has %d",

-		  node, nelems, shouldkids, nkids);

-	}

-    }

-

-    /*

-     * nelems should be at least 1.

-     */

-    if (nelems == 0) {

-	error("node %p: no elems", node, nkids);

-    }

-

-    /*

-     * Add nelems to the running element count of the whole tree.

-     */

-    ctx->elemcount += nelems;

-

-    /*

-     * Check ordering property: all elements should be strictly >

-     * lowbound, strictly < highbound, and strictly < each other in

-     * sequence. (lowbound and highbound are NULL at edges of tree

-     * - both NULL at root node - and NULL is considered to be <

-     * everything and > everything. IYSWIM.)

-     */

-    if (cmp) {

-	for (i = -1; i < nelems; i++) {

-	    void *lower = (i == -1 ? lowbound : node->elems[i]);

-	    void *higher =

-		(i + 1 == nelems ? highbound : node->elems[i + 1]);

-	    if (lower && higher && cmp(lower, higher) >= 0) {

-		error("node %p: kid comparison [%d=%s,%d=%s] failed",

-		      node, i, lower, i + 1, higher);

-	    }

-	}

-    }

-

-    /*

-     * Check parent pointers: all non-NULL kids should have a

-     * parent pointer coming back to this node.

-     */

-    for (i = 0; i < nkids; i++)

-	if (node->kids[i]->parent != node) {

-	    error("node %p kid %d: parent ptr is %p not %p",

-		  node, i, node->kids[i]->parent, node);

-	}

-

-

-    /*

-     * Now (finally!) recurse into subtrees.

-     */

-    count = nelems;

-

-    for (i = 0; i < nkids; i++) {

-	void *lower = (i == 0 ? lowbound : node->elems[i - 1]);

-	void *higher = (i >= nelems ? highbound : node->elems[i]);

-	int subcount =

-	    chknode(ctx, level + 1, node->kids[i], lower, higher);

-	if (node->counts[i] != subcount) {

-	    error("node %p kid %d: count says %d, subtree really has %d",

-		  node, i, node->counts[i], subcount);

-	}

-	count += subcount;

-    }

-

-    return count;

-}

-

-void verify(void)

-{

-    chkctx ctx;

-    int i;

-    void *p;

-

-    ctx.treedepth = -1;		       /* depth unknown yet */

-    ctx.elemcount = 0;		       /* no elements seen yet */

-    /*

-     * Verify validity of tree properties.

-     */

-    if (tree->root) {

-	if (tree->root->parent != NULL)

-	    error("root->parent is %p should be null", tree->root->parent);

-	chknode(&ctx, 0, tree->root, NULL, NULL);

-    }

-    printf("tree depth: %d\n", ctx.treedepth);

-    /*

-     * Enumerate the tree and ensure it matches up to the array.

-     */

-    for (i = 0; NULL != (p = index234(tree, i)); i++) {

-	if (i >= arraylen)

-	    error("tree contains more than %d elements", arraylen);

-	if (array[i] != p)

-	    error("enum at position %d: array says %s, tree says %s",

-		  i, array[i], p);

-    }

-    if (ctx.elemcount != i) {

-	error("tree really contains %d elements, enum gave %d",

-	      ctx.elemcount, i);

-    }

-    if (i < arraylen) {

-	error("enum gave only %d elements, array has %d", i, arraylen);

-    }

-    i = count234(tree);

-    if (ctx.elemcount != i) {

-	error("tree really contains %d elements, count234 gave %d",

-	      ctx.elemcount, i);

-    }

-}

-

-void internal_addtest(void *elem, int index, void *realret)

-{

-    int i, j;

-    void *retval;

-

-    if (arraysize < arraylen + 1) {

-	arraysize = arraylen + 1 + 256;

-	array = sresize(array, arraysize, void *);

-    }

-

-    i = index;

-    /* now i points to the first element >= elem */

-    retval = elem;		       /* expect elem returned (success) */

-    for (j = arraylen; j > i; j--)

-	array[j] = array[j - 1];

-    array[i] = elem;		       /* add elem to array */

-    arraylen++;

-

-    if (realret != retval) {

-	error("add: retval was %p expected %p", realret, retval);

-    }

-

-    verify();

-}

-

-void addtest(void *elem)

-{

-    int i;

-    void *realret;

-

-    realret = add234(tree, elem);

-

-    i = 0;

-    while (i < arraylen && cmp(elem, array[i]) > 0)

-	i++;

-    if (i < arraylen && !cmp(elem, array[i])) {

-	void *retval = array[i];       /* expect that returned not elem */

-	if (realret != retval) {

-	    error("add: retval was %p expected %p", realret, retval);

-	}

-    } else

-	internal_addtest(elem, i, realret);

-}

-

-void addpostest(void *elem, int i)

-{

-    void *realret;

-

-    realret = addpos234(tree, elem, i);

-

-    internal_addtest(elem, i, realret);

-}

-

-void delpostest(int i)

-{

-    int index = i;

-    void *elem = array[i], *ret;

-

-    /* i points to the right element */

-    while (i < arraylen - 1) {

-	array[i] = array[i + 1];

-	i++;

-    }

-    arraylen--;			       /* delete elem from array */

-

-    if (tree->cmp)

-	ret = del234(tree, elem);

-    else

-	ret = delpos234(tree, index);

-

-    if (ret != elem) {

-	error("del returned %p, expected %p", ret, elem);

-    }

-

-    verify();

-}

-

-void deltest(void *elem)

-{

-    int i;

-

-    i = 0;

-    while (i < arraylen && cmp(elem, array[i]) > 0)

-	i++;

-    if (i >= arraylen || cmp(elem, array[i]) != 0)

-	return;			       /* don't do it! */

-    delpostest(i);

-}

-

-/* A sample data set and test utility. Designed for pseudo-randomness,

- * and yet repeatability. */

-

-/*

- * This random number generator uses the `portable implementation'

- * given in ANSI C99 draft N869. It assumes `unsigned' is 32 bits;

- * change it if not.

- */

-int randomnumber(unsigned *seed)

-{

-    *seed *= 1103515245;

-    *seed += 12345;

-    return ((*seed) / 65536) % 32768;

-}

-

-int mycmp(void *av, void *bv)

-{

-    char const *a = (char const *) av;

-    char const *b = (char const *) bv;

-    return strcmp(a, b);

-}

-

-#define lenof(x) ( sizeof((x)) / sizeof(*(x)) )

-

-char *strings[] = {

-    "a", "ab", "absque", "coram", "de",

-    "palam", "clam", "cum", "ex", "e",

-    "sine", "tenus", "pro", "prae",

-    "banana", "carrot", "cabbage", "broccoli", "onion", "zebra",

-    "penguin", "blancmange", "pangolin", "whale", "hedgehog",

-    "giraffe", "peanut", "bungee", "foo", "bar", "baz", "quux",

-    "murfl", "spoo", "breen", "flarn", "octothorpe",

-    "snail", "tiger", "elephant", "octopus", "warthog", "armadillo",

-    "aardvark", "wyvern", "dragon", "elf", "dwarf", "orc", "goblin",

-    "pixie", "basilisk", "warg", "ape", "lizard", "newt", "shopkeeper",

-    "wand", "ring", "amulet"

-};

-

-#define NSTR lenof(strings)

-

-int findtest(void)

-{

-    const static int rels[] = {

-	REL234_EQ, REL234_GE, REL234_LE, REL234_LT, REL234_GT

-    };

-    const static char *const relnames[] = {

-	"EQ", "GE", "LE", "LT", "GT"

-    };

-    int i, j, rel, index;

-    char *p, *ret, *realret, *realret2;

-    int lo, hi, mid, c;

-

-    for (i = 0; i < NSTR; i++) {

-	p = strings[i];

-	for (j = 0; j < sizeof(rels) / sizeof(*rels); j++) {

-	    rel = rels[j];

-

-	    lo = 0;

-	    hi = arraylen - 1;

-	    while (lo <= hi) {

-		mid = (lo + hi) / 2;

-		c = strcmp(p, array[mid]);

-		if (c < 0)

-		    hi = mid - 1;

-		else if (c > 0)

-		    lo = mid + 1;

-		else

-		    break;

-	    }

-

-	    if (c == 0) {

-		if (rel == REL234_LT)

-		    ret = (mid > 0 ? array[--mid] : NULL);

-		else if (rel == REL234_GT)

-		    ret = (mid < arraylen - 1 ? array[++mid] : NULL);

-		else

-		    ret = array[mid];

-	    } else {

-		assert(lo == hi + 1);

-		if (rel == REL234_LT || rel == REL234_LE) {

-		    mid = hi;

-		    ret = (hi >= 0 ? array[hi] : NULL);

-		} else if (rel == REL234_GT || rel == REL234_GE) {

-		    mid = lo;

-		    ret = (lo < arraylen ? array[lo] : NULL);

-		} else

-		    ret = NULL;

-	    }

-

-	    realret = findrelpos234(tree, p, NULL, rel, &index);

-	    if (realret != ret) {

-		error("find(\"%s\",%s) gave %s should be %s",

-		      p, relnames[j], realret, ret);

-	    }

-	    if (realret && index != mid) {

-		error("find(\"%s\",%s) gave %d should be %d",

-		      p, relnames[j], index, mid);

-	    }

-	    if (realret && rel == REL234_EQ) {

-		realret2 = index234(tree, index);

-		if (realret2 != realret) {

-		    error("find(\"%s\",%s) gave %s(%d) but %d -> %s",

-			  p, relnames[j], realret, index, index, realret2);

-		}

-	    }

-#if 0

-	    printf("find(\"%s\",%s) gave %s(%d)\n", p, relnames[j],

-		   realret, index);

-#endif

-	}

-    }

-

-    realret = findrelpos234(tree, NULL, NULL, REL234_GT, &index);

-    if (arraylen && (realret != array[0] || index != 0)) {

-	error("find(NULL,GT) gave %s(%d) should be %s(0)",

-	      realret, index, array[0]);

-    } else if (!arraylen && (realret != NULL)) {

-	error("find(NULL,GT) gave %s(%d) should be NULL", realret, index);

-    }

-

-    realret = findrelpos234(tree, NULL, NULL, REL234_LT, &index);

-    if (arraylen

-	&& (realret != array[arraylen - 1] || index != arraylen - 1)) {

-	error("find(NULL,LT) gave %s(%d) should be %s(0)", realret, index,

-	      array[arraylen - 1]);

-    } else if (!arraylen && (realret != NULL)) {

-	error("find(NULL,LT) gave %s(%d) should be NULL", realret, index);

-    }

-}

-

-int main(void)

-{

-    int in[NSTR];

-    int i, j, k;

-    unsigned seed = 0;

-

-    for (i = 0; i < NSTR; i++)

-	in[i] = 0;

-    array = NULL;

-    arraylen = arraysize = 0;

-    tree = newtree234(mycmp);

-    cmp = mycmp;

-

-    verify();

-    for (i = 0; i < 10000; i++) {

-	j = randomnumber(&seed);

-	j %= NSTR;

-	printf("trial: %d\n", i);

-	if (in[j]) {

-	    printf("deleting %s (%d)\n", strings[j], j);

-	    deltest(strings[j]);

-	    in[j] = 0;

-	} else {

-	    printf("adding %s (%d)\n", strings[j], j);

-	    addtest(strings[j]);

-	    in[j] = 1;

-	}

-	findtest();

-    }

-

-    while (arraylen > 0) {

-	j = randomnumber(&seed);

-	j %= arraylen;

-	deltest(array[j]);

-    }

-

-    freetree234(tree);

-

-    /*

-     * Now try an unsorted tree. We don't really need to test

-     * delpos234 because we know del234 is based on it, so it's

-     * already been tested in the above sorted-tree code; but for

-     * completeness we'll use it to tear down our unsorted tree

-     * once we've built it.

-     */

-    tree = newtree234(NULL);

-    cmp = NULL;

-    verify();

-    for (i = 0; i < 1000; i++) {

-	printf("trial: %d\n", i);

-	j = randomnumber(&seed);

-	j %= NSTR;

-	k = randomnumber(&seed);

-	k %= count234(tree) + 1;

-	printf("adding string %s at index %d\n", strings[j], k);

-	addpostest(strings[j], k);

-    }

-    while (count234(tree) > 0) {

-	printf("cleanup: tree size %d\n", count234(tree));

-	j = randomnumber(&seed);

-	j %= count234(tree);

-	printf("deleting string %s from index %d\n", array[j], j);

-	delpostest(j);

-    }

-

-    return 0;

-}

-

-#endif

+/*
+ * tree234.c: reasonably generic counted 2-3-4 tree routines.
+ * 
+ * This file is copyright 1999-2001 Simon Tatham.
+ * 
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "tree234.h"
+
+#ifdef TEST
+#define LOG(x) (printf x)
+#define snew(type) ((type *)malloc(sizeof(type)))
+#define snewn(n, type) ((type *)malloc((n) * sizeof(type)))
+#define sresize(ptr, n, type)                                         \
+    ((type *)realloc(sizeof((type *)0 == (ptr)) ? (ptr) : (ptr),      \
+                     (n) * sizeof(type)))
+#define sfree(ptr) free(ptr)
+#else
+#include "puttymem.h"
+#define LOG(x)
+#endif
+
+typedef struct node234_Tag node234;
+
+struct tree234_Tag {
+    node234 *root;
+    cmpfn234 cmp;
+};
+
+struct node234_Tag {
+    node234 *parent;
+    node234 *kids[4];
+    int counts[4];
+    void *elems[3];
+};
+
+/*
+ * Create a 2-3-4 tree.
+ */
+tree234 *newtree234(cmpfn234 cmp)
+{
+    tree234 *ret = snew(tree234);
+    LOG(("created tree %p\n", ret));
+    ret->root = NULL;
+    ret->cmp = cmp;
+    return ret;
+}
+
+/*
+ * Free a 2-3-4 tree (not including freeing the elements).
+ */
+static void freenode234(node234 * n)
+{
+    if (!n)
+	return;
+    freenode234(n->kids[0]);
+    freenode234(n->kids[1]);
+    freenode234(n->kids[2]);
+    freenode234(n->kids[3]);
+    sfree(n);
+}
+
+void freetree234(tree234 * t)
+{
+    freenode234(t->root);
+    sfree(t);
+}
+
+/*
+ * Internal function to count a node.
+ */
+static int countnode234(node234 * n)
+{
+    int count = 0;
+    int i;
+    if (!n)
+	return 0;
+    for (i = 0; i < 4; i++)
+	count += n->counts[i];
+    for (i = 0; i < 3; i++)
+	if (n->elems[i])
+	    count++;
+    return count;
+}
+
+/*
+ * Count the elements in a tree.
+ */
+int count234(tree234 * t)
+{
+    if (t->root)
+	return countnode234(t->root);
+    else
+	return 0;
+}
+
+/*
+ * Add an element e to a 2-3-4 tree t. Returns e on success, or if
+ * an existing element compares equal, returns that.
+ */
+static void *add234_internal(tree234 * t, void *e, int index)
+{
+    node234 *n, **np, *left, *right;
+    void *orig_e = e;
+    int c, lcount, rcount;
+
+    LOG(("adding node %p to tree %p\n", e, t));
+    if (t->root == NULL) {
+	t->root = snew(node234);
+	t->root->elems[1] = t->root->elems[2] = NULL;
+	t->root->kids[0] = t->root->kids[1] = NULL;
+	t->root->kids[2] = t->root->kids[3] = NULL;
+	t->root->counts[0] = t->root->counts[1] = 0;
+	t->root->counts[2] = t->root->counts[3] = 0;
+	t->root->parent = NULL;
+	t->root->elems[0] = e;
+	LOG(("  created root %p\n", t->root));
+	return orig_e;
+    }
+
+    n = NULL; /* placate gcc; will always be set below since t->root != NULL */
+    np = &t->root;
+    while (*np) {
+	int childnum;
+	n = *np;
+	LOG(("  node %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d\n",
+	     n,
+	     n->kids[0], n->counts[0], n->elems[0],
+	     n->kids[1], n->counts[1], n->elems[1],
+	     n->kids[2], n->counts[2], n->elems[2],
+	     n->kids[3], n->counts[3]));
+	if (index >= 0) {
+	    if (!n->kids[0]) {
+		/*
+		 * Leaf node. We want to insert at kid position
+		 * equal to the index:
+		 * 
+		 *   0 A 1 B 2 C 3
+		 */
+		childnum = index;
+	    } else {
+		/*
+		 * Internal node. We always descend through it (add
+		 * always starts at the bottom, never in the
+		 * middle).
+		 */
+		do {		       /* this is a do ... while (0) to allow `break' */
+		    if (index <= n->counts[0]) {
+			childnum = 0;
+			break;
+		    }
+		    index -= n->counts[0] + 1;
+		    if (index <= n->counts[1]) {
+			childnum = 1;
+			break;
+		    }
+		    index -= n->counts[1] + 1;
+		    if (index <= n->counts[2]) {
+			childnum = 2;
+			break;
+		    }
+		    index -= n->counts[2] + 1;
+		    if (index <= n->counts[3]) {
+			childnum = 3;
+			break;
+		    }
+		    return NULL;       /* error: index out of range */
+		} while (0);
+	    }
+	} else {
+	    if ((c = t->cmp(e, n->elems[0])) < 0)
+		childnum = 0;
+	    else if (c == 0)
+		return n->elems[0];    /* already exists */
+	    else if (n->elems[1] == NULL
+		     || (c = t->cmp(e, n->elems[1])) < 0) childnum = 1;
+	    else if (c == 0)
+		return n->elems[1];    /* already exists */
+	    else if (n->elems[2] == NULL
+		     || (c = t->cmp(e, n->elems[2])) < 0) childnum = 2;
+	    else if (c == 0)
+		return n->elems[2];    /* already exists */
+	    else
+		childnum = 3;
+	}
+	np = &n->kids[childnum];
+	LOG(("  moving to child %d (%p)\n", childnum, *np));
+    }
+
+    /*
+     * We need to insert the new element in n at position np.
+     */
+    left = NULL;
+    lcount = 0;
+    right = NULL;
+    rcount = 0;
+    while (n) {
+	LOG(("  at %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d\n",
+	     n,
+	     n->kids[0], n->counts[0], n->elems[0],
+	     n->kids[1], n->counts[1], n->elems[1],
+	     n->kids[2], n->counts[2], n->elems[2],
+	     n->kids[3], n->counts[3]));
+	LOG(("  need to insert %p/%d [%p] %p/%d at position %d\n",
+	     left, lcount, e, right, rcount, (int)(np - n->kids)));
+	if (n->elems[1] == NULL) {
+	    /*
+	     * Insert in a 2-node; simple.
+	     */
+	    if (np == &n->kids[0]) {
+		LOG(("  inserting on left of 2-node\n"));
+		n->kids[2] = n->kids[1];
+		n->counts[2] = n->counts[1];
+		n->elems[1] = n->elems[0];
+		n->kids[1] = right;
+		n->counts[1] = rcount;
+		n->elems[0] = e;
+		n->kids[0] = left;
+		n->counts[0] = lcount;
+	    } else {		       /* np == &n->kids[1] */
+		LOG(("  inserting on right of 2-node\n"));
+		n->kids[2] = right;
+		n->counts[2] = rcount;
+		n->elems[1] = e;
+		n->kids[1] = left;
+		n->counts[1] = lcount;
+	    }
+	    if (n->kids[0])
+		n->kids[0]->parent = n;
+	    if (n->kids[1])
+		n->kids[1]->parent = n;
+	    if (n->kids[2])
+		n->kids[2]->parent = n;
+	    LOG(("  done\n"));
+	    break;
+	} else if (n->elems[2] == NULL) {
+	    /*
+	     * Insert in a 3-node; simple.
+	     */
+	    if (np == &n->kids[0]) {
+		LOG(("  inserting on left of 3-node\n"));
+		n->kids[3] = n->kids[2];
+		n->counts[3] = n->counts[2];
+		n->elems[2] = n->elems[1];
+		n->kids[2] = n->kids[1];
+		n->counts[2] = n->counts[1];
+		n->elems[1] = n->elems[0];
+		n->kids[1] = right;
+		n->counts[1] = rcount;
+		n->elems[0] = e;
+		n->kids[0] = left;
+		n->counts[0] = lcount;
+	    } else if (np == &n->kids[1]) {
+		LOG(("  inserting in middle of 3-node\n"));
+		n->kids[3] = n->kids[2];
+		n->counts[3] = n->counts[2];
+		n->elems[2] = n->elems[1];
+		n->kids[2] = right;
+		n->counts[2] = rcount;
+		n->elems[1] = e;
+		n->kids[1] = left;
+		n->counts[1] = lcount;
+	    } else {		       /* np == &n->kids[2] */
+		LOG(("  inserting on right of 3-node\n"));
+		n->kids[3] = right;
+		n->counts[3] = rcount;
+		n->elems[2] = e;
+		n->kids[2] = left;
+		n->counts[2] = lcount;
+	    }
+	    if (n->kids[0])
+		n->kids[0]->parent = n;
+	    if (n->kids[1])
+		n->kids[1]->parent = n;
+	    if (n->kids[2])
+		n->kids[2]->parent = n;
+	    if (n->kids[3])
+		n->kids[3]->parent = n;
+	    LOG(("  done\n"));
+	    break;
+	} else {
+	    node234 *m = snew(node234);
+	    m->parent = n->parent;
+	    LOG(("  splitting a 4-node; created new node %p\n", m));
+	    /*
+	     * Insert in a 4-node; split into a 2-node and a
+	     * 3-node, and move focus up a level.
+	     * 
+	     * I don't think it matters which way round we put the
+	     * 2 and the 3. For simplicity, we'll put the 3 first
+	     * always.
+	     */
+	    if (np == &n->kids[0]) {
+		m->kids[0] = left;
+		m->counts[0] = lcount;
+		m->elems[0] = e;
+		m->kids[1] = right;
+		m->counts[1] = rcount;
+		m->elems[1] = n->elems[0];
+		m->kids[2] = n->kids[1];
+		m->counts[2] = n->counts[1];
+		e = n->elems[1];
+		n->kids[0] = n->kids[2];
+		n->counts[0] = n->counts[2];
+		n->elems[0] = n->elems[2];
+		n->kids[1] = n->kids[3];
+		n->counts[1] = n->counts[3];
+	    } else if (np == &n->kids[1]) {
+		m->kids[0] = n->kids[0];
+		m->counts[0] = n->counts[0];
+		m->elems[0] = n->elems[0];
+		m->kids[1] = left;
+		m->counts[1] = lcount;
+		m->elems[1] = e;
+		m->kids[2] = right;
+		m->counts[2] = rcount;
+		e = n->elems[1];
+		n->kids[0] = n->kids[2];
+		n->counts[0] = n->counts[2];
+		n->elems[0] = n->elems[2];
+		n->kids[1] = n->kids[3];
+		n->counts[1] = n->counts[3];
+	    } else if (np == &n->kids[2]) {
+		m->kids[0] = n->kids[0];
+		m->counts[0] = n->counts[0];
+		m->elems[0] = n->elems[0];
+		m->kids[1] = n->kids[1];
+		m->counts[1] = n->counts[1];
+		m->elems[1] = n->elems[1];
+		m->kids[2] = left;
+		m->counts[2] = lcount;
+		/* e = e; */
+		n->kids[0] = right;
+		n->counts[0] = rcount;
+		n->elems[0] = n->elems[2];
+		n->kids[1] = n->kids[3];
+		n->counts[1] = n->counts[3];
+	    } else {		       /* np == &n->kids[3] */
+		m->kids[0] = n->kids[0];
+		m->counts[0] = n->counts[0];
+		m->elems[0] = n->elems[0];
+		m->kids[1] = n->kids[1];
+		m->counts[1] = n->counts[1];
+		m->elems[1] = n->elems[1];
+		m->kids[2] = n->kids[2];
+		m->counts[2] = n->counts[2];
+		n->kids[0] = left;
+		n->counts[0] = lcount;
+		n->elems[0] = e;
+		n->kids[1] = right;
+		n->counts[1] = rcount;
+		e = n->elems[2];
+	    }
+	    m->kids[3] = n->kids[3] = n->kids[2] = NULL;
+	    m->counts[3] = n->counts[3] = n->counts[2] = 0;
+	    m->elems[2] = n->elems[2] = n->elems[1] = NULL;
+	    if (m->kids[0])
+		m->kids[0]->parent = m;
+	    if (m->kids[1])
+		m->kids[1]->parent = m;
+	    if (m->kids[2])
+		m->kids[2]->parent = m;
+	    if (n->kids[0])
+		n->kids[0]->parent = n;
+	    if (n->kids[1])
+		n->kids[1]->parent = n;
+	    LOG(("  left (%p): %p/%d [%p] %p/%d [%p] %p/%d\n", m,
+		 m->kids[0], m->counts[0], m->elems[0],
+		 m->kids[1], m->counts[1], m->elems[1],
+		 m->kids[2], m->counts[2]));
+	    LOG(("  right (%p): %p/%d [%p] %p/%d\n", n,
+		 n->kids[0], n->counts[0], n->elems[0],
+		 n->kids[1], n->counts[1]));
+	    left = m;
+	    lcount = countnode234(left);
+	    right = n;
+	    rcount = countnode234(right);
+	}
+	if (n->parent)
+	    np = (n->parent->kids[0] == n ? &n->parent->kids[0] :
+		  n->parent->kids[1] == n ? &n->parent->kids[1] :
+		  n->parent->kids[2] == n ? &n->parent->kids[2] :
+		  &n->parent->kids[3]);
+	n = n->parent;
+    }
+
+    /*
+     * If we've come out of here by `break', n will still be
+     * non-NULL and all we need to do is go back up the tree
+     * updating counts. If we've come here because n is NULL, we
+     * need to create a new root for the tree because the old one
+     * has just split into two. */
+    if (n) {
+	while (n->parent) {
+	    int count = countnode234(n);
+	    int childnum;
+	    childnum = (n->parent->kids[0] == n ? 0 :
+			n->parent->kids[1] == n ? 1 :
+			n->parent->kids[2] == n ? 2 : 3);
+	    n->parent->counts[childnum] = count;
+	    n = n->parent;
+	}
+    } else {
+	LOG(("  root is overloaded, split into two\n"));
+	t->root = snew(node234);
+	t->root->kids[0] = left;
+	t->root->counts[0] = lcount;
+	t->root->elems[0] = e;
+	t->root->kids[1] = right;
+	t->root->counts[1] = rcount;
+	t->root->elems[1] = NULL;
+	t->root->kids[2] = NULL;
+	t->root->counts[2] = 0;
+	t->root->elems[2] = NULL;
+	t->root->kids[3] = NULL;
+	t->root->counts[3] = 0;
+	t->root->parent = NULL;
+	if (t->root->kids[0])
+	    t->root->kids[0]->parent = t->root;
+	if (t->root->kids[1])
+	    t->root->kids[1]->parent = t->root;
+	LOG(("  new root is %p/%d [%p] %p/%d\n",
+	     t->root->kids[0], t->root->counts[0],
+	     t->root->elems[0], t->root->kids[1], t->root->counts[1]));
+    }
+
+    return orig_e;
+}
+
+void *add234(tree234 * t, void *e)
+{
+    if (!t->cmp)		       /* tree is unsorted */
+	return NULL;
+
+    return add234_internal(t, e, -1);
+}
+void *addpos234(tree234 * t, void *e, int index)
+{
+    if (index < 0 ||		       /* index out of range */
+	t->cmp)			       /* tree is sorted */
+	return NULL;		       /* return failure */
+
+    return add234_internal(t, e, index);	/* this checks the upper bound */
+}
+
+/*
+ * Look up the element at a given numeric index in a 2-3-4 tree.
+ * Returns NULL if the index is out of range.
+ */
+void *index234(tree234 * t, int index)
+{
+    node234 *n;
+
+    if (!t->root)
+	return NULL;		       /* tree is empty */
+
+    if (index < 0 || index >= countnode234(t->root))
+	return NULL;		       /* out of range */
+
+    n = t->root;
+
+    while (n) {
+	if (index < n->counts[0])
+	    n = n->kids[0];
+	else if (index -= n->counts[0] + 1, index < 0)
+	    return n->elems[0];
+	else if (index < n->counts[1])
+	    n = n->kids[1];
+	else if (index -= n->counts[1] + 1, index < 0)
+	    return n->elems[1];
+	else if (index < n->counts[2])
+	    n = n->kids[2];
+	else if (index -= n->counts[2] + 1, index < 0)
+	    return n->elems[2];
+	else
+	    n = n->kids[3];
+    }
+
+    /* We shouldn't ever get here. I wonder how we did. */
+    return NULL;
+}
+
+/*
+ * Find an element e in a sorted 2-3-4 tree t. Returns NULL if not
+ * found. e is always passed as the first argument to cmp, so cmp
+ * can be an asymmetric function if desired. cmp can also be passed
+ * as NULL, in which case the compare function from the tree proper
+ * will be used.
+ */
+void *findrelpos234(tree234 * t, void *e, cmpfn234 cmp,
+		    int relation, int *index)
+{
+    node234 *n;
+    void *ret;
+    int c;
+    int idx, ecount, kcount, cmpret;
+
+    if (t->root == NULL)
+	return NULL;
+
+    if (cmp == NULL)
+	cmp = t->cmp;
+
+    n = t->root;
+    /*
+     * Attempt to find the element itself.
+     */
+    idx = 0;
+    ecount = -1;
+    /*
+     * Prepare a fake `cmp' result if e is NULL.
+     */
+    cmpret = 0;
+    if (e == NULL) {
+	assert(relation == REL234_LT || relation == REL234_GT);
+	if (relation == REL234_LT)
+	    cmpret = +1;	       /* e is a max: always greater */
+	else if (relation == REL234_GT)
+	    cmpret = -1;	       /* e is a min: always smaller */
+    }
+    while (1) {
+	for (kcount = 0; kcount < 4; kcount++) {
+	    if (kcount >= 3 || n->elems[kcount] == NULL ||
+		(c = cmpret ? cmpret : cmp(e, n->elems[kcount])) < 0) {
+		break;
+	    }
+	    if (n->kids[kcount])
+		idx += n->counts[kcount];
+	    if (c == 0) {
+		ecount = kcount;
+		break;
+	    }
+	    idx++;
+	}
+	if (ecount >= 0)
+	    break;
+	if (n->kids[kcount])
+	    n = n->kids[kcount];
+	else
+	    break;
+    }
+
+    if (ecount >= 0) {
+	/*
+	 * We have found the element we're looking for. It's
+	 * n->elems[ecount], at tree index idx. If our search
+	 * relation is EQ, LE or GE we can now go home.
+	 */
+	if (relation != REL234_LT && relation != REL234_GT) {
+	    if (index)
+		*index = idx;
+	    return n->elems[ecount];
+	}
+
+	/*
+	 * Otherwise, we'll do an indexed lookup for the previous
+	 * or next element. (It would be perfectly possible to
+	 * implement these search types in a non-counted tree by
+	 * going back up from where we are, but far more fiddly.)
+	 */
+	if (relation == REL234_LT)
+	    idx--;
+	else
+	    idx++;
+    } else {
+	/*
+	 * We've found our way to the bottom of the tree and we
+	 * know where we would insert this node if we wanted to:
+	 * we'd put it in in place of the (empty) subtree
+	 * n->kids[kcount], and it would have index idx
+	 * 
+	 * But the actual element isn't there. So if our search
+	 * relation is EQ, we're doomed.
+	 */
+	if (relation == REL234_EQ)
+	    return NULL;
+
+	/*
+	 * Otherwise, we must do an index lookup for index idx-1
+	 * (if we're going left - LE or LT) or index idx (if we're
+	 * going right - GE or GT).
+	 */
+	if (relation == REL234_LT || relation == REL234_LE) {
+	    idx--;
+	}
+    }
+
+    /*
+     * We know the index of the element we want; just call index234
+     * to do the rest. This will return NULL if the index is out of
+     * bounds, which is exactly what we want.
+     */
+    ret = index234(t, idx);
+    if (ret && index)
+	*index = idx;
+    return ret;
+}
+void *find234(tree234 * t, void *e, cmpfn234 cmp)
+{
+    return findrelpos234(t, e, cmp, REL234_EQ, NULL);
+}
+void *findrel234(tree234 * t, void *e, cmpfn234 cmp, int relation)
+{
+    return findrelpos234(t, e, cmp, relation, NULL);
+}
+void *findpos234(tree234 * t, void *e, cmpfn234 cmp, int *index)
+{
+    return findrelpos234(t, e, cmp, REL234_EQ, index);
+}
+
+/*
+ * Delete an element e in a 2-3-4 tree. Does not free the element,
+ * merely removes all links to it from the tree nodes.
+ */
+static void *delpos234_internal(tree234 * t, int index)
+{
+    node234 *n;
+    void *retval;
+    int ei = -1;
+
+    retval = 0;
+
+    n = t->root;
+    LOG(("deleting item %d from tree %p\n", index, t));
+    while (1) {
+	while (n) {
+	    int ki;
+	    node234 *sub;
+
+	    LOG(
+		("  node %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d index=%d\n",
+		 n, n->kids[0], n->counts[0], n->elems[0], n->kids[1],
+		 n->counts[1], n->elems[1], n->kids[2], n->counts[2],
+		 n->elems[2], n->kids[3], n->counts[3], index));
+	    if (index < n->counts[0]) {
+		ki = 0;
+	    } else if (index -= n->counts[0] + 1, index < 0) {
+		ei = 0;
+		break;
+	    } else if (index < n->counts[1]) {
+		ki = 1;
+	    } else if (index -= n->counts[1] + 1, index < 0) {
+		ei = 1;
+		break;
+	    } else if (index < n->counts[2]) {
+		ki = 2;
+	    } else if (index -= n->counts[2] + 1, index < 0) {
+		ei = 2;
+		break;
+	    } else {
+		ki = 3;
+	    }
+	    /*
+	     * Recurse down to subtree ki. If it has only one element,
+	     * we have to do some transformation to start with.
+	     */
+	    LOG(("  moving to subtree %d\n", ki));
+	    sub = n->kids[ki];
+	    if (!sub->elems[1]) {
+		LOG(("  subtree has only one element!\n", ki));
+		if (ki > 0 && n->kids[ki - 1]->elems[1]) {
+		    /*
+		     * Case 3a, left-handed variant. Child ki has
+		     * only one element, but child ki-1 has two or
+		     * more. So we need to move a subtree from ki-1
+		     * to ki.
+		     * 
+		     *                . C .                     . B .
+		     *               /     \     ->            /     \
+		     * [more] a A b B c   d D e      [more] a A b   c C d D e
+		     */
+		    node234 *sib = n->kids[ki - 1];
+		    int lastelem = (sib->elems[2] ? 2 :
+				    sib->elems[1] ? 1 : 0);
+		    sub->kids[2] = sub->kids[1];
+		    sub->counts[2] = sub->counts[1];
+		    sub->elems[1] = sub->elems[0];
+		    sub->kids[1] = sub->kids[0];
+		    sub->counts[1] = sub->counts[0];
+		    sub->elems[0] = n->elems[ki - 1];
+		    sub->kids[0] = sib->kids[lastelem + 1];
+		    sub->counts[0] = sib->counts[lastelem + 1];
+		    if (sub->kids[0])
+			sub->kids[0]->parent = sub;
+		    n->elems[ki - 1] = sib->elems[lastelem];
+		    sib->kids[lastelem + 1] = NULL;
+		    sib->counts[lastelem + 1] = 0;
+		    sib->elems[lastelem] = NULL;
+		    n->counts[ki] = countnode234(sub);
+		    LOG(("  case 3a left\n"));
+		    LOG(
+			("  index and left subtree count before adjustment: %d, %d\n",
+			 index, n->counts[ki - 1]));
+		    index += n->counts[ki - 1];
+		    n->counts[ki - 1] = countnode234(sib);
+		    index -= n->counts[ki - 1];
+		    LOG(
+			("  index and left subtree count after adjustment: %d, %d\n",
+			 index, n->counts[ki - 1]));
+		} else if (ki < 3 && n->kids[ki + 1]
+			   && n->kids[ki + 1]->elems[1]) {
+		    /*
+		     * Case 3a, right-handed variant. ki has only
+		     * one element but ki+1 has two or more. Move a
+		     * subtree from ki+1 to ki.
+		     * 
+		     *      . B .                             . C .
+		     *     /     \                ->         /     \
+		     *  a A b   c C d D e [more]      a A b B c   d D e [more]
+		     */
+		    node234 *sib = n->kids[ki + 1];
+		    int j;
+		    sub->elems[1] = n->elems[ki];
+		    sub->kids[2] = sib->kids[0];
+		    sub->counts[2] = sib->counts[0];
+		    if (sub->kids[2])
+			sub->kids[2]->parent = sub;
+		    n->elems[ki] = sib->elems[0];
+		    sib->kids[0] = sib->kids[1];
+		    sib->counts[0] = sib->counts[1];
+		    for (j = 0; j < 2 && sib->elems[j + 1]; j++) {
+			sib->kids[j + 1] = sib->kids[j + 2];
+			sib->counts[j + 1] = sib->counts[j + 2];
+			sib->elems[j] = sib->elems[j + 1];
+		    }
+		    sib->kids[j + 1] = NULL;
+		    sib->counts[j + 1] = 0;
+		    sib->elems[j] = NULL;
+		    n->counts[ki] = countnode234(sub);
+		    n->counts[ki + 1] = countnode234(sib);
+		    LOG(("  case 3a right\n"));
+		} else {
+		    /*
+		     * Case 3b. ki has only one element, and has no
+		     * neighbour with more than one. So pick a
+		     * neighbour and merge it with ki, taking an
+		     * element down from n to go in the middle.
+		     *
+		     *      . B .                .
+		     *     /     \     ->        |
+		     *  a A b   c C d      a A b B c C d
+		     * 
+		     * (Since at all points we have avoided
+		     * descending to a node with only one element,
+		     * we can be sure that n is not reduced to
+		     * nothingness by this move, _unless_ it was
+		     * the very first node, ie the root of the
+		     * tree. In that case we remove the now-empty
+		     * root and replace it with its single large
+		     * child as shown.)
+		     */
+		    node234 *sib;
+		    int j;
+
+		    if (ki > 0) {
+			ki--;
+			index += n->counts[ki] + 1;
+		    }
+		    sib = n->kids[ki];
+		    sub = n->kids[ki + 1];
+
+		    sub->kids[3] = sub->kids[1];
+		    sub->counts[3] = sub->counts[1];
+		    sub->elems[2] = sub->elems[0];
+		    sub->kids[2] = sub->kids[0];
+		    sub->counts[2] = sub->counts[0];
+		    sub->elems[1] = n->elems[ki];
+		    sub->kids[1] = sib->kids[1];
+		    sub->counts[1] = sib->counts[1];
+		    if (sub->kids[1])
+			sub->kids[1]->parent = sub;
+		    sub->elems[0] = sib->elems[0];
+		    sub->kids[0] = sib->kids[0];
+		    sub->counts[0] = sib->counts[0];
+		    if (sub->kids[0])
+			sub->kids[0]->parent = sub;
+
+		    n->counts[ki + 1] = countnode234(sub);
+
+		    sfree(sib);
+
+		    /*
+		     * That's built the big node in sub. Now we
+		     * need to remove the reference to sib in n.
+		     */
+		    for (j = ki; j < 3 && n->kids[j + 1]; j++) {
+			n->kids[j] = n->kids[j + 1];
+			n->counts[j] = n->counts[j + 1];
+			n->elems[j] = j < 2 ? n->elems[j + 1] : NULL;
+		    }
+		    n->kids[j] = NULL;
+		    n->counts[j] = 0;
+		    if (j < 3)
+			n->elems[j] = NULL;
+		    LOG(("  case 3b ki=%d\n", ki));
+
+		    if (!n->elems[0]) {
+			/*
+			 * The root is empty and needs to be
+			 * removed.
+			 */
+			LOG(("  shifting root!\n"));
+			t->root = sub;
+			sub->parent = NULL;
+			sfree(n);
+		    }
+		}
+	    }
+	    n = sub;
+	}
+	if (!retval)
+	    retval = n->elems[ei];
+
+	if (ei == -1)
+	    return NULL;	       /* although this shouldn't happen */
+
+	/*
+	 * Treat special case: this is the one remaining item in
+	 * the tree. n is the tree root (no parent), has one
+	 * element (no elems[1]), and has no kids (no kids[0]).
+	 */
+	if (!n->parent && !n->elems[1] && !n->kids[0]) {
+	    LOG(("  removed last element in tree\n"));
+	    sfree(n);
+	    t->root = NULL;
+	    return retval;
+	}
+
+	/*
+	 * Now we have the element we want, as n->elems[ei], and we
+	 * have also arranged for that element not to be the only
+	 * one in its node. So...
+	 */
+
+	if (!n->kids[0] && n->elems[1]) {
+	    /*
+	     * Case 1. n is a leaf node with more than one element,
+	     * so it's _really easy_. Just delete the thing and
+	     * we're done.
+	     */
+	    int i;
+	    LOG(("  case 1\n"));
+	    for (i = ei; i < 2 && n->elems[i + 1]; i++)
+		n->elems[i] = n->elems[i + 1];
+	    n->elems[i] = NULL;
+	    /*
+	     * Having done that to the leaf node, we now go back up
+	     * the tree fixing the counts.
+	     */
+	    while (n->parent) {
+		int childnum;
+		childnum = (n->parent->kids[0] == n ? 0 :
+			    n->parent->kids[1] == n ? 1 :
+			    n->parent->kids[2] == n ? 2 : 3);
+		n->parent->counts[childnum]--;
+		n = n->parent;
+	    }
+	    return retval;	       /* finished! */
+	} else if (n->kids[ei]->elems[1]) {
+	    /*
+	     * Case 2a. n is an internal node, and the root of the
+	     * subtree to the left of e has more than one element.
+	     * So find the predecessor p to e (ie the largest node
+	     * in that subtree), place it where e currently is, and
+	     * then start the deletion process over again on the
+	     * subtree with p as target.
+	     */
+	    node234 *m = n->kids[ei];
+	    void *target;
+	    LOG(("  case 2a\n"));
+	    while (m->kids[0]) {
+		m = (m->kids[3] ? m->kids[3] :
+		     m->kids[2] ? m->kids[2] :
+		     m->kids[1] ? m->kids[1] : m->kids[0]);
+	    }
+	    target = (m->elems[2] ? m->elems[2] :
+		      m->elems[1] ? m->elems[1] : m->elems[0]);
+	    n->elems[ei] = target;
+	    index = n->counts[ei] - 1;
+	    n = n->kids[ei];
+	} else if (n->kids[ei + 1]->elems[1]) {
+	    /*
+	     * Case 2b, symmetric to 2a but s/left/right/ and
+	     * s/predecessor/successor/. (And s/largest/smallest/).
+	     */
+	    node234 *m = n->kids[ei + 1];
+	    void *target;
+	    LOG(("  case 2b\n"));
+	    while (m->kids[0]) {
+		m = m->kids[0];
+	    }
+	    target = m->elems[0];
+	    n->elems[ei] = target;
+	    n = n->kids[ei + 1];
+	    index = 0;
+	} else {
+	    /*
+	     * Case 2c. n is an internal node, and the subtrees to
+	     * the left and right of e both have only one element.
+	     * So combine the two subnodes into a single big node
+	     * with their own elements on the left and right and e
+	     * in the middle, then restart the deletion process on
+	     * that subtree, with e still as target.
+	     */
+	    node234 *a = n->kids[ei], *b = n->kids[ei + 1];
+	    int j;
+
+	    LOG(("  case 2c\n"));
+	    a->elems[1] = n->elems[ei];
+	    a->kids[2] = b->kids[0];
+	    a->counts[2] = b->counts[0];
+	    if (a->kids[2])
+		a->kids[2]->parent = a;
+	    a->elems[2] = b->elems[0];
+	    a->kids[3] = b->kids[1];
+	    a->counts[3] = b->counts[1];
+	    if (a->kids[3])
+		a->kids[3]->parent = a;
+	    sfree(b);
+	    n->counts[ei] = countnode234(a);
+	    /*
+	     * That's built the big node in a, and destroyed b. Now
+	     * remove the reference to b (and e) in n.
+	     */
+	    for (j = ei; j < 2 && n->elems[j + 1]; j++) {
+		n->elems[j] = n->elems[j + 1];
+		n->kids[j + 1] = n->kids[j + 2];
+		n->counts[j + 1] = n->counts[j + 2];
+	    }
+	    n->elems[j] = NULL;
+	    n->kids[j + 1] = NULL;
+	    n->counts[j + 1] = 0;
+	    /*
+	     * It's possible, in this case, that we've just removed
+	     * the only element in the root of the tree. If so,
+	     * shift the root.
+	     */
+	    if (n->elems[0] == NULL) {
+		LOG(("  shifting root!\n"));
+		t->root = a;
+		a->parent = NULL;
+		sfree(n);
+	    }
+	    /*
+	     * Now go round the deletion process again, with n
+	     * pointing at the new big node and e still the same.
+	     */
+	    n = a;
+	    index = a->counts[0] + a->counts[1] + 1;
+	}
+    }
+}
+void *delpos234(tree234 * t, int index)
+{
+    if (index < 0 || index >= countnode234(t->root))
+	return NULL;
+    return delpos234_internal(t, index);
+}
+void *del234(tree234 * t, void *e)
+{
+    int index;
+    if (!findrelpos234(t, e, NULL, REL234_EQ, &index))
+	return NULL;		       /* it wasn't in there anyway */
+    return delpos234_internal(t, index);	/* it's there; delete it. */
+}
+
+#ifdef TEST
+
+/*
+ * Test code for the 2-3-4 tree. This code maintains an alternative
+ * representation of the data in the tree, in an array (using the
+ * obvious and slow insert and delete functions). After each tree
+ * operation, the verify() function is called, which ensures all
+ * the tree properties are preserved:
+ *  - node->child->parent always equals node
+ *  - tree->root->parent always equals NULL
+ *  - number of kids == 0 or number of elements + 1;
+ *  - tree has the same depth everywhere
+ *  - every node has at least one element
+ *  - subtree element counts are accurate
+ *  - any NULL kid pointer is accompanied by a zero count
+ *  - in a sorted tree: ordering property between elements of a
+ *    node and elements of its children is preserved
+ * and also ensures the list represented by the tree is the same
+ * list it should be. (This last check also doubly verifies the
+ * ordering properties, because the `same list it should be' is by
+ * definition correctly ordered. It also ensures all nodes are
+ * distinct, because the enum functions would get caught in a loop
+ * if not.)
+ */
+
+#include <stdarg.h>
+
+/*
+ * Error reporting function.
+ */
+void error(char *fmt, ...)
+{
+    va_list ap;
+    printf("ERROR: ");
+    va_start(ap, fmt);
+    vfprintf(stdout, fmt, ap);
+    va_end(ap);
+    printf("\n");
+}
+
+/* The array representation of the data. */
+void **array;
+int arraylen, arraysize;
+cmpfn234 cmp;
+
+/* The tree representation of the same data. */
+tree234 *tree;
+
+typedef struct {
+    int treedepth;
+    int elemcount;
+} chkctx;
+
+int chknode(chkctx * ctx, int level, node234 * node,
+	    void *lowbound, void *highbound)
+{
+    int nkids, nelems;
+    int i;
+    int count;
+
+    /* Count the non-NULL kids. */
+    for (nkids = 0; nkids < 4 && node->kids[nkids]; nkids++);
+    /* Ensure no kids beyond the first NULL are non-NULL. */
+    for (i = nkids; i < 4; i++)
+	if (node->kids[i]) {
+	    error("node %p: nkids=%d but kids[%d] non-NULL",
+		  node, nkids, i);
+	} else if (node->counts[i]) {
+	    error("node %p: kids[%d] NULL but count[%d]=%d nonzero",
+		  node, i, i, node->counts[i]);
+	}
+
+    /* Count the non-NULL elements. */
+    for (nelems = 0; nelems < 3 && node->elems[nelems]; nelems++);
+    /* Ensure no elements beyond the first NULL are non-NULL. */
+    for (i = nelems; i < 3; i++)
+	if (node->elems[i]) {
+	    error("node %p: nelems=%d but elems[%d] non-NULL",
+		  node, nelems, i);
+	}
+
+    if (nkids == 0) {
+	/*
+	 * If nkids==0, this is a leaf node; verify that the tree
+	 * depth is the same everywhere.
+	 */
+	if (ctx->treedepth < 0)
+	    ctx->treedepth = level;    /* we didn't know the depth yet */
+	else if (ctx->treedepth != level)
+	    error("node %p: leaf at depth %d, previously seen depth %d",
+		  node, level, ctx->treedepth);
+    } else {
+	/*
+	 * If nkids != 0, then it should be nelems+1, unless nelems
+	 * is 0 in which case nkids should also be 0 (and so we
+	 * shouldn't be in this condition at all).
+	 */
+	int shouldkids = (nelems ? nelems + 1 : 0);
+	if (nkids != shouldkids) {
+	    error("node %p: %d elems should mean %d kids but has %d",
+		  node, nelems, shouldkids, nkids);
+	}
+    }
+
+    /*
+     * nelems should be at least 1.
+     */
+    if (nelems == 0) {
+	error("node %p: no elems", node, nkids);
+    }
+
+    /*
+     * Add nelems to the running element count of the whole tree.
+     */
+    ctx->elemcount += nelems;
+
+    /*
+     * Check ordering property: all elements should be strictly >
+     * lowbound, strictly < highbound, and strictly < each other in
+     * sequence. (lowbound and highbound are NULL at edges of tree
+     * - both NULL at root node - and NULL is considered to be <
+     * everything and > everything. IYSWIM.)
+     */
+    if (cmp) {
+	for (i = -1; i < nelems; i++) {
+	    void *lower = (i == -1 ? lowbound : node->elems[i]);
+	    void *higher =
+		(i + 1 == nelems ? highbound : node->elems[i + 1]);
+	    if (lower && higher && cmp(lower, higher) >= 0) {
+		error("node %p: kid comparison [%d=%s,%d=%s] failed",
+		      node, i, lower, i + 1, higher);
+	    }
+	}
+    }
+
+    /*
+     * Check parent pointers: all non-NULL kids should have a
+     * parent pointer coming back to this node.
+     */
+    for (i = 0; i < nkids; i++)
+	if (node->kids[i]->parent != node) {
+	    error("node %p kid %d: parent ptr is %p not %p",
+		  node, i, node->kids[i]->parent, node);
+	}
+
+
+    /*
+     * Now (finally!) recurse into subtrees.
+     */
+    count = nelems;
+
+    for (i = 0; i < nkids; i++) {
+	void *lower = (i == 0 ? lowbound : node->elems[i - 1]);
+	void *higher = (i >= nelems ? highbound : node->elems[i]);
+	int subcount =
+	    chknode(ctx, level + 1, node->kids[i], lower, higher);
+	if (node->counts[i] != subcount) {
+	    error("node %p kid %d: count says %d, subtree really has %d",
+		  node, i, node->counts[i], subcount);
+	}
+	count += subcount;
+    }
+
+    return count;
+}
+
+void verify(void)
+{
+    chkctx ctx;
+    int i;
+    void *p;
+
+    ctx.treedepth = -1;		       /* depth unknown yet */
+    ctx.elemcount = 0;		       /* no elements seen yet */
+    /*
+     * Verify validity of tree properties.
+     */
+    if (tree->root) {
+	if (tree->root->parent != NULL)
+	    error("root->parent is %p should be null", tree->root->parent);
+	chknode(&ctx, 0, tree->root, NULL, NULL);
+    }
+    printf("tree depth: %d\n", ctx.treedepth);
+    /*
+     * Enumerate the tree and ensure it matches up to the array.
+     */
+    for (i = 0; NULL != (p = index234(tree, i)); i++) {
+	if (i >= arraylen)
+	    error("tree contains more than %d elements", arraylen);
+	if (array[i] != p)
+	    error("enum at position %d: array says %s, tree says %s",
+		  i, array[i], p);
+    }
+    if (ctx.elemcount != i) {
+	error("tree really contains %d elements, enum gave %d",
+	      ctx.elemcount, i);
+    }
+    if (i < arraylen) {
+	error("enum gave only %d elements, array has %d", i, arraylen);
+    }
+    i = count234(tree);
+    if (ctx.elemcount != i) {
+	error("tree really contains %d elements, count234 gave %d",
+	      ctx.elemcount, i);
+    }
+}
+
+void internal_addtest(void *elem, int index, void *realret)
+{
+    int i, j;
+    void *retval;
+
+    if (arraysize < arraylen + 1) {
+	arraysize = arraylen + 1 + 256;
+	array = sresize(array, arraysize, void *);
+    }
+
+    i = index;
+    /* now i points to the first element >= elem */
+    retval = elem;		       /* expect elem returned (success) */
+    for (j = arraylen; j > i; j--)
+	array[j] = array[j - 1];
+    array[i] = elem;		       /* add elem to array */
+    arraylen++;
+
+    if (realret != retval) {
+	error("add: retval was %p expected %p", realret, retval);
+    }
+
+    verify();
+}
+
+void addtest(void *elem)
+{
+    int i;
+    void *realret;
+
+    realret = add234(tree, elem);
+
+    i = 0;
+    while (i < arraylen && cmp(elem, array[i]) > 0)
+	i++;
+    if (i < arraylen && !cmp(elem, array[i])) {
+	void *retval = array[i];       /* expect that returned not elem */
+	if (realret != retval) {
+	    error("add: retval was %p expected %p", realret, retval);
+	}
+    } else
+	internal_addtest(elem, i, realret);
+}
+
+void addpostest(void *elem, int i)
+{
+    void *realret;
+
+    realret = addpos234(tree, elem, i);
+
+    internal_addtest(elem, i, realret);
+}
+
+void delpostest(int i)
+{
+    int index = i;
+    void *elem = array[i], *ret;
+
+    /* i points to the right element */
+    while (i < arraylen - 1) {
+	array[i] = array[i + 1];
+	i++;
+    }
+    arraylen--;			       /* delete elem from array */
+
+    if (tree->cmp)
+	ret = del234(tree, elem);
+    else
+	ret = delpos234(tree, index);
+
+    if (ret != elem) {
+	error("del returned %p, expected %p", ret, elem);
+    }
+
+    verify();
+}
+
+void deltest(void *elem)
+{
+    int i;
+
+    i = 0;
+    while (i < arraylen && cmp(elem, array[i]) > 0)
+	i++;
+    if (i >= arraylen || cmp(elem, array[i]) != 0)
+	return;			       /* don't do it! */
+    delpostest(i);
+}
+
+/* A sample data set and test utility. Designed for pseudo-randomness,
+ * and yet repeatability. */
+
+/*
+ * This random number generator uses the `portable implementation'
+ * given in ANSI C99 draft N869. It assumes `unsigned' is 32 bits;
+ * change it if not.
+ */
+int randomnumber(unsigned *seed)
+{
+    *seed *= 1103515245;
+    *seed += 12345;
+    return ((*seed) / 65536) % 32768;
+}
+
+int mycmp(void *av, void *bv)
+{
+    char const *a = (char const *) av;
+    char const *b = (char const *) bv;
+    return strcmp(a, b);
+}
+
+#define lenof(x) ( sizeof((x)) / sizeof(*(x)) )
+
+char *strings[] = {
+    "a", "ab", "absque", "coram", "de",
+    "palam", "clam", "cum", "ex", "e",
+    "sine", "tenus", "pro", "prae",
+    "banana", "carrot", "cabbage", "broccoli", "onion", "zebra",
+    "penguin", "blancmange", "pangolin", "whale", "hedgehog",
+    "giraffe", "peanut", "bungee", "foo", "bar", "baz", "quux",
+    "murfl", "spoo", "breen", "flarn", "octothorpe",
+    "snail", "tiger", "elephant", "octopus", "warthog", "armadillo",
+    "aardvark", "wyvern", "dragon", "elf", "dwarf", "orc", "goblin",
+    "pixie", "basilisk", "warg", "ape", "lizard", "newt", "shopkeeper",
+    "wand", "ring", "amulet"
+};
+
+#define NSTR lenof(strings)
+
+int findtest(void)
+{
+    const static int rels[] = {
+	REL234_EQ, REL234_GE, REL234_LE, REL234_LT, REL234_GT
+    };
+    const static char *const relnames[] = {
+	"EQ", "GE", "LE", "LT", "GT"
+    };
+    int i, j, rel, index;
+    char *p, *ret, *realret, *realret2;
+    int lo, hi, mid, c;
+
+    for (i = 0; i < NSTR; i++) {
+	p = strings[i];
+	for (j = 0; j < sizeof(rels) / sizeof(*rels); j++) {
+	    rel = rels[j];
+
+	    lo = 0;
+	    hi = arraylen - 1;
+	    while (lo <= hi) {
+		mid = (lo + hi) / 2;
+		c = strcmp(p, array[mid]);
+		if (c < 0)
+		    hi = mid - 1;
+		else if (c > 0)
+		    lo = mid + 1;
+		else
+		    break;
+	    }
+
+	    if (c == 0) {
+		if (rel == REL234_LT)
+		    ret = (mid > 0 ? array[--mid] : NULL);
+		else if (rel == REL234_GT)
+		    ret = (mid < arraylen - 1 ? array[++mid] : NULL);
+		else
+		    ret = array[mid];
+	    } else {
+		assert(lo == hi + 1);
+		if (rel == REL234_LT || rel == REL234_LE) {
+		    mid = hi;
+		    ret = (hi >= 0 ? array[hi] : NULL);
+		} else if (rel == REL234_GT || rel == REL234_GE) {
+		    mid = lo;
+		    ret = (lo < arraylen ? array[lo] : NULL);
+		} else
+		    ret = NULL;
+	    }
+
+	    realret = findrelpos234(tree, p, NULL, rel, &index);
+	    if (realret != ret) {
+		error("find(\"%s\",%s) gave %s should be %s",
+		      p, relnames[j], realret, ret);
+	    }
+	    if (realret && index != mid) {
+		error("find(\"%s\",%s) gave %d should be %d",
+		      p, relnames[j], index, mid);
+	    }
+	    if (realret && rel == REL234_EQ) {
+		realret2 = index234(tree, index);
+		if (realret2 != realret) {
+		    error("find(\"%s\",%s) gave %s(%d) but %d -> %s",
+			  p, relnames[j], realret, index, index, realret2);
+		}
+	    }
+#if 0
+	    printf("find(\"%s\",%s) gave %s(%d)\n", p, relnames[j],
+		   realret, index);
+#endif
+	}
+    }
+
+    realret = findrelpos234(tree, NULL, NULL, REL234_GT, &index);
+    if (arraylen && (realret != array[0] || index != 0)) {
+	error("find(NULL,GT) gave %s(%d) should be %s(0)",
+	      realret, index, array[0]);
+    } else if (!arraylen && (realret != NULL)) {
+	error("find(NULL,GT) gave %s(%d) should be NULL", realret, index);
+    }
+
+    realret = findrelpos234(tree, NULL, NULL, REL234_LT, &index);
+    if (arraylen
+	&& (realret != array[arraylen - 1] || index != arraylen - 1)) {
+	error("find(NULL,LT) gave %s(%d) should be %s(0)", realret, index,
+	      array[arraylen - 1]);
+    } else if (!arraylen && (realret != NULL)) {
+	error("find(NULL,LT) gave %s(%d) should be NULL", realret, index);
+    }
+}
+
+int main(void)
+{
+    int in[NSTR];
+    int i, j, k;
+    unsigned seed = 0;
+
+    for (i = 0; i < NSTR; i++)
+	in[i] = 0;
+    array = NULL;
+    arraylen = arraysize = 0;
+    tree = newtree234(mycmp);
+    cmp = mycmp;
+
+    verify();
+    for (i = 0; i < 10000; i++) {
+	j = randomnumber(&seed);
+	j %= NSTR;
+	printf("trial: %d\n", i);
+	if (in[j]) {
+	    printf("deleting %s (%d)\n", strings[j], j);
+	    deltest(strings[j]);
+	    in[j] = 0;
+	} else {
+	    printf("adding %s (%d)\n", strings[j], j);
+	    addtest(strings[j]);
+	    in[j] = 1;
+	}
+	findtest();
+    }
+
+    while (arraylen > 0) {
+	j = randomnumber(&seed);
+	j %= arraylen;
+	deltest(array[j]);
+    }
+
+    freetree234(tree);
+
+    /*
+     * Now try an unsorted tree. We don't really need to test
+     * delpos234 because we know del234 is based on it, so it's
+     * already been tested in the above sorted-tree code; but for
+     * completeness we'll use it to tear down our unsorted tree
+     * once we've built it.
+     */
+    tree = newtree234(NULL);
+    cmp = NULL;
+    verify();
+    for (i = 0; i < 1000; i++) {
+	printf("trial: %d\n", i);
+	j = randomnumber(&seed);
+	j %= NSTR;
+	k = randomnumber(&seed);
+	k %= count234(tree) + 1;
+	printf("adding string %s at index %d\n", strings[j], k);
+	addpostest(strings[j], k);
+    }
+    while (count234(tree) > 0) {
+	printf("cleanup: tree size %d\n", count234(tree));
+	j = randomnumber(&seed);
+	j %= count234(tree);
+	printf("deleting string %s from index %d\n",
+               (const char *)array[j], j);
+	delpostest(j);
+    }
+
+    return 0;
+}
+
+#endif