===================================================================
RCS file: /cvs/mandoc/Attic/apropos_db.c,v
retrieving revision 1.26
retrieving revision 1.28
diff -u -p -r1.26 -r1.28
--- mandoc/Attic/apropos_db.c	2011/12/16 20:06:58	1.26
+++ mandoc/Attic/apropos_db.c	2011/12/25 14:58:39	1.28
@@ -1,4 +1,4 @@
-/*	$Id: apropos_db.c,v 1.26 2011/12/16 20:06:58 kristaps Exp $ */
+/*	$Id: apropos_db.c,v 1.28 2011/12/25 14:58:39 schwarze Exp $ */
 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
@@ -123,8 +123,8 @@ static	const struct type types[] = {
 
 static	DB	*btree_open(void);
 static	int	 btree_read(const DBT *, const DBT *,
-			const struct mchars *, 
-			struct db_val *, char **);
+			const struct mchars *,
+			uint64_t *, recno_t *, char **);
 static	int	 expreval(const struct expr *, int *);
 static	void	 exprexec(const struct expr *,
 			const char *, uint64_t, struct rec *);
@@ -167,24 +167,23 @@ btree_open(void)
  * Return 0 if the database is insane, else 1.
  */
 static int
-btree_read(const DBT *k, const DBT *v, 
-		const struct mchars *mc, 
-		struct db_val *dbv, char **buf)
+btree_read(const DBT *k, const DBT *v, const struct mchars *mc,
+		uint64_t *mask, recno_t *rec, char **buf)
 {
-	const struct db_val *vp;
+	uint64_t	 vbuf[2];
 
 	/* Are our sizes sane? */
-	if (k->size < 2 || sizeof(struct db_val) != v->size)
+	if (k->size < 2 || sizeof(vbuf) != v->size)
 		return(0);
 
 	/* Is our string nil-terminated? */
 	if ('\0' != ((const char *)k->data)[(int)k->size - 1])
 		return(0);
 
-	vp = v->data;
 	norm_string((const char *)k->data, mc, buf);
-	dbv->rec = betoh32(vp->rec);
-	dbv->mask = betoh64(vp->mask);
+	memcpy(vbuf, v->data, v->size);
+	*mask = betoh64(vbuf[0]);
+	*rec  = betoh64(vbuf[1]);
 	return(1);
 }
 
@@ -380,7 +379,8 @@ index_read(const DBT *key, const DBT *val, int index,
 		return(0);
 
 	cp = val->data;
-	rec->res.rec = *(recno_t *)key->data;
+	assert(sizeof(recno_t) == key->size);
+	memcpy(&rec->res.rec, key->data, key->size);
 	rec->res.volume = index;
 
 	if ('d' == (type = *cp++))
@@ -474,7 +474,8 @@ single_search(struct rectree *tree, const struct opts 
 	char		*buf;
 	struct rec	*rs;
 	struct rec	 r;
-	struct db_val	 vb;
+	uint64_t	 mask;
+	recno_t		 rec;
 
 	root	= -1;
 	leaf	= -1;
@@ -494,14 +495,14 @@ single_search(struct rectree *tree, const struct opts 
 	}
 
 	while (0 == (ch = (*btree->seq)(btree, &key, &val, R_NEXT))) {
-		if ( ! btree_read(&key, &val, mc, &vb, &buf))
+		if ( ! btree_read(&key, &val, mc, &mask, &rec, &buf))
 			break;
 
 		/*
 		 * See if this keyword record matches any of the
 		 * expressions we have stored.
 		 */
-		if ( ! exprmark(expr, buf, vb.mask, NULL))
+		if ( ! exprmark(expr, buf, mask, NULL))
 			continue;
 
 		/*
@@ -511,10 +512,10 @@ single_search(struct rectree *tree, const struct opts 
 		 */
 
 		for (leaf = root; leaf >= 0; )
-			if (vb.rec > rs[leaf].res.rec &&
+			if (rec > rs[leaf].res.rec &&
 					rs[leaf].rhs >= 0)
 				leaf = rs[leaf].rhs;
-			else if (vb.rec < rs[leaf].res.rec &&
+			else if (rec < rs[leaf].res.rec &&
 					rs[leaf].lhs >= 0)
 				leaf = rs[leaf].lhs;
 			else
@@ -526,9 +527,9 @@ single_search(struct rectree *tree, const struct opts 
 		 * try to evaluate it now and continue anyway.
 		 */
 
-		if (leaf >= 0 && rs[leaf].res.rec == vb.rec) {
+		if (leaf >= 0 && rs[leaf].res.rec == rec) {
 			if (0 == rs[leaf].matched)
-				exprexec(expr, buf, vb.mask, &rs[leaf]);
+				exprexec(expr, buf, mask, &rs[leaf]);
 			continue;
 		}
 
@@ -538,7 +539,7 @@ single_search(struct rectree *tree, const struct opts 
 		 * database, then begin partial evaluation.
 		 */
 
-		key.data = &vb.rec;
+		key.data = &rec;
 		key.size = sizeof(recno_t);
 
 		if (0 != (*idx->get)(idx, &key, &val, 0))
@@ -565,12 +566,12 @@ single_search(struct rectree *tree, const struct opts 
 		rs[tree->len].matches =
 			mandoc_calloc(terms, sizeof(int));
 
-		exprexec(expr, buf, vb.mask, &rs[tree->len]);
+		exprexec(expr, buf, mask, &rs[tree->len]);
 
 		/* Append to our tree. */
 
 		if (leaf >= 0) {
-			if (vb.rec > rs[leaf].res.rec)
+			if (rec > rs[leaf].res.rec)
 				rs[leaf].rhs = tree->len;
 			else
 				rs[leaf].lhs = tree->len;