mdocml: For binary compatability of the databases across architectures,

[schwarze@mdocml.bsd.lv]

Log Message:
-----------
For binary compatability of the databases across architectures, 
use pointers to arrays, not pointers to structs.  It is now possible 
to create databases on sparc64 and use them on i386 and vice versa.
Kristaps@ can't think of anything else that might be required, either.
Put this in now such that we can move on.

Modified Files:
--------------
    mdocml:
        apropos_db.c
        mandocdb.c
        mandocdb.h

Revision Data
-------------
Index: apropos_db.c
===================================================================
RCS file: /usr/vhosts/mdocml.bsd.lv/cvs/mdocml/apropos_db.c,v
retrieving revision 1.27
retrieving revision 1.28
diff -Lapropos_db.c -Lapropos_db.c -u -p -r1.27 -r1.28
--- apropos_db.c
+++ apropos_db.c
@@ -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,14 +167,13 @@ 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)
 {
-	struct db_val	 raw_dbv;
+	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? */
@@ -182,9 +181,9 @@ btree_read(const DBT *k, const DBT *v, 
 		return(0);
 
 	norm_string((const char *)k->data, mc, buf);
-	memcpy(&raw_dbv, v->data, v->size);
-	dbv->rec = betoh32(raw_dbv.rec);
-	dbv->mask = betoh64(raw_dbv.mask);
+	memcpy(vbuf, v->data, v->size);
+	*mask = betoh64(vbuf[0]);
+	*rec  = betoh64(vbuf[1]);
 	return(1);
 }
 
@@ -475,7 +474,8 @@ single_search(struct rectree *tree, cons
 	char		*buf;
 	struct rec	*rs;
 	struct rec	 r;
-	struct db_val	 vb;
+	uint64_t	 mask;
+	recno_t		 rec;
 
 	root	= -1;
 	leaf	= -1;
@@ -495,14 +495,14 @@ single_search(struct rectree *tree, cons
 	}
 
 	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;
 
 		/*
@@ -512,10 +512,10 @@ single_search(struct rectree *tree, cons
 		 */
 
 		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
@@ -527,9 +527,9 @@ single_search(struct rectree *tree, cons
 		 * 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;
 		}
 
@@ -539,7 +539,7 @@ single_search(struct rectree *tree, cons
 		 * 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))
@@ -566,12 +566,12 @@ single_search(struct rectree *tree, cons
 		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;
Index: mandocdb.h
===================================================================
RCS file: /usr/vhosts/mdocml.bsd.lv/cvs/mdocml/mandocdb.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -Lmandocdb.h -Lmandocdb.h -u -p -r1.3 -r1.4
--- mandocdb.h
+++ mandocdb.h
@@ -17,11 +17,6 @@
 #ifndef MANDOCDB_H
 #define MANDOCDB_H
 
-struct db_val {
-	uint64_t	mask;
-	uint32_t	rec;
-};
-
 #define	MANDOC_DB	"mandoc.db"
 #define	MANDOC_IDX	"mandoc.index"
 
Index: mandocdb.c
===================================================================
RCS file: /usr/vhosts/mdocml.bsd.lv/cvs/mdocml/mandocdb.c,v
retrieving revision 1.38
retrieving revision 1.39
diff -Lmandocdb.c -Lmandocdb.c -u -p -r1.38 -r1.39
--- mandocdb.c
+++ mandocdb.c
@@ -575,7 +575,7 @@ index_merge(const struct of *of, struct 
 	uint64_t	 mask;
 	size_t		 sv;
 	unsigned	 seq;
-	struct db_val	 vbuf;
+	uint64_t	 vbuf[2];
 	char		 type;
 
 	rec = 0;
@@ -714,7 +714,7 @@ index_merge(const struct of *of, struct 
 			recs->last = 0;
 		} else
 			rec++;
-		vbuf.rec = htobe32(rec);
+		vbuf[1] = htobe64(rec);
 
 		/*
 		 * Copy from the in-memory hashtable of pending
@@ -726,8 +726,8 @@ index_merge(const struct of *of, struct 
 			seq = R_NEXT;
 			assert(sizeof(uint64_t) == val.size);
 			memcpy(&mask, val.data, val.size);
-			vbuf.mask = htobe64(mask);
-			val.size = sizeof(struct db_val);
+			vbuf[0] = htobe64(mask);
+			val.size = sizeof(vbuf);
 			val.data = &vbuf;
 			dbt_put(mdb->db, mdb->dbn, &key, &val);
 		}
@@ -768,7 +768,7 @@ index_prune(const struct of *ofile, stru
 {
 	const struct of	*of;
 	const char	*fn;
-	struct db_val	*vbuf;
+	uint64_t	 vbuf[2];
 	unsigned	 seq, sseq;
 	DBT		 key, val;
 	int		 ch;
@@ -817,11 +817,11 @@ index_prune(const struct of *ofile, stru
 		while (0 == (ch = (*mdb->db->seq)(mdb->db,
 					&key, &val, sseq))) {
 			sseq = R_NEXT;
-			if (sizeof(struct db_val) != val.size)
+			if (sizeof(vbuf) != val.size)
 				break;
 
-			vbuf = val.data;
-			if (recs->last != betoh32(vbuf->rec))
+			memcpy(vbuf, val.data, val.size);
+			if (recs->last != betoh64(vbuf[1]))
 				continue;
 
 			if ((ch = (*mdb->db->del)(mdb->db,
--
 To unsubscribe send an email to source+unsubscribe@mdocml.bsd.lv