indent -i4

git-svn-id: http://opensvn.csie.org/pttbbs/trunk/pttbbs@1473 63ad8ddf-47c3-0310-b6dd-a9e9d9715204

1 files changed, 1379 insertions, 1412 deletions

diff --git a/innbbsd/dbz.c b/innbbsd/dbz.c
index 6fd15df8..58616968 100644
--- a/innbbsd/dbz.c
+++ b/innbbsd/dbz.c
@@ -1,33 +1,32 @@
 /*
-
-dbz.c  V3.2
-
-Copyright 1988 Jon Zeeff (zeeff@b-tech.ann-arbor.mi.us)
-You can use this code in any manner, as long as you leave my name on it
-and don't hold me responsible for any problems with it.
-
-Hacked on by gdb@ninja.UUCP (David Butler); Sun Jun  5 00:27:08 CDT 1988
-
-Various improvments + INCORE by moraes@ai.toronto.edu (Mark Moraes)
-
-Major reworking by Henry Spencer as part of the C News project.
-
-Minor lint and CodeCenter (Saber) fluff removal by Rich $alz (March, 1991).
-Non-portable CloseOnExec() calls added by Rich $alz (September, 1991).
-Added "writethrough" and tagmask calculation code from
-<rob@violet.berkeley.edu> and <leres@ee.lbl.gov> by Rich $alz (December, 1992).
-Merged in MMAP code by David Robinson, formerly <david@elroy.jpl.nasa.gov>
-now <david.robinson@sun.com> (January, 1993).
-
-These routines replace dbm as used by the usenet news software
-(it's not a full dbm replacement by any means).  It's fast and
-simple.  It contains no AT&T code.
-
-In general, dbz's files are 1/20 the size of dbm's.  Lookup performance
-is somewhat better, while file creation is spectacularly faster, especially
-if the incore facility is used.
-
-*/
+ * dbz.c  V3.2
+ * 
+ * Copyright 1988 Jon Zeeff (zeeff@b-tech.ann-arbor.mi.us) You can use this code
+ * in any manner, as long as you leave my name on it and don't hold me
+ * responsible for any problems with it.
+ * 
+ * Hacked on by gdb@ninja.UUCP (David Butler); Sun Jun  5 00:27:08 CDT 1988
+ * 
+ * Various improvments + INCORE by moraes@ai.toronto.edu (Mark Moraes)
+ * 
+ * Major reworking by Henry Spencer as part of the C News project.
+ * 
+ * Minor lint and CodeCenter (Saber) fluff removal by Rich $alz (March, 1991).
+ * Non-portable CloseOnExec() calls added by Rich $alz (September, 1991).
+ * Added "writethrough" and tagmask calculation code from
+ * <rob@violet.berkeley.edu> and <leres@ee.lbl.gov> by Rich $alz (December,
+ * 1992). Merged in MMAP code by David Robinson, formerly
+ * <david@elroy.jpl.nasa.gov> now <david.robinson@sun.com> (January, 1993).
+ * 
+ * These routines replace dbm as used by the usenet news software (it's not a
+ * full dbm replacement by any means).  It's fast and simple.  It contains no
+ * AT&T code.
+ * 
+ * In general, dbz's files are 1/20 the size of dbm's.  Lookup performance is
+ * somewhat better, while file creation is spectacularly faster, especially
+ * if the incore facility is used.
+ * 
+ */
 
 #include <stdio.h>
 #include <sys/types.h>
@@ -35,26 +34,24 @@ if the incore facility is used.
 #include <ctype.h>
 #include <errno.h>
 #ifndef __STDC__
-extern int errno;
+extern int      errno;
 #endif
 #include <dbz.h>
 #include "clibrary.h"
 
 /*
  * #ifdef index.  "LIA" = "leave it alone unless you know what you're doing".
- *
- * FUNNYSEEKS	SEEK_SET is not 0, get it from <unistd.h>
- * INDEX_SIZE	backward compatibility with old dbz; avoid using this
- * NMEMORY	number of days of memory for use in sizing new table (LIA)
- * INCORE	backward compatibility with old dbz; use dbzincore() instead
- * DBZDEBUG	enable debugging
- * DEFSIZE	default table size (not as critical as in old dbz)
- * OLDBNEWS	default case mapping as in old B News; set NOBUFFER
+ * 
+ * FUNNYSEEKS	SEEK_SET is not 0, get it from <unistd.h> INDEX_SIZE
+ * backward compatibility with old dbz; avoid using this NMEMORY
+ * number of days of memory for use in sizing new table (LIA) INCORE
+ * backward compatibility with old dbz; use dbzincore() instead DBZDEBUG
+ * enable debugging DEFSIZE	default table size (not as critical as in old
+ * dbz) OLDBNEWS	default case mapping as in old B News; set NOBUFFER
  * BNEWS	default case mapping as in current B News; set NOBUFFER
- * DEFCASE	default case-map algorithm selector
- * NOTAGS	fseek offsets are strange, do not do tagging (see below)
- * NPAGBUF	size of .pag buffer, in longs (LIA)
- * SHISTBUF	size of ASCII-file buffer, in bytes (LIA)
+ * DEFCASE	default case-map algorithm selector NOTAGS	fseek offsets
+ * are strange, do not do tagging (see below) NPAGBUF	size of .pag buffer,
+ * in longs (LIA) SHISTBUF	size of ASCII-file buffer, in bytes (LIA)
  * MAXRUN	length of run which shifts to next table (see below) (LIA)
  * OVERFLOW	long-int arithmetic overflow must be avoided, will trap
  * NOBUFFER	do not buffer hash-table i/o, B News locking is defective
@@ -72,35 +69,35 @@ extern int errno;
 #include <limits.h>
 #endif
 
-static int dbzversion = 3;	/* for validating .dir file format */
+static int      dbzversion = 3;	/* for validating .dir file format */
 
 /*
  * The dbz database exploits the fact that when news stores a <key,value>
- * tuple, the `value' part is a seek offset into a text file, pointing to
- * a copy of the `key' part.  This avoids the need to store a copy of
- * the key in the dbz files.  However, the text file *must* exist and be
- * consistent with the dbz files, or things will fail.
- *
+ * tuple, the `value' part is a seek offset into a text file, pointing to a
+ * copy of the `key' part.  This avoids the need to store a copy of the key
+ * in the dbz files.  However, the text file *must* exist and be consistent
+ * with the dbz files, or things will fail.
+ * 
  * The basic format of the database is a simple hash table containing the
  * values.  A value is stored by indexing into the table using a hash value
  * computed from the key; collisions are resolved by linear probing (just
- * search forward for an empty slot, wrapping around to the beginning of
- * the table if necessary).  Linear probing is a performance disaster when
- * the table starts to get full, so a complication is introduced.  The
- * database is actually one *or more* tables, stored sequentially in the
- * .pag file, and the length of linear-probe sequences is limited.  The
- * search (for an existing item or an empty slot) always starts in the
- * first table, and whenever MAXRUN probes have been done in table N,
- * probing continues in table N+1.  This behaves reasonably well even in
- * cases of massive overflow.  There are some other small complications
- * added, see comments below.
- *
+ * search forward for an empty slot, wrapping around to the beginning of the
+ * table if necessary).  Linear probing is a performance disaster when the
+ * table starts to get full, so a complication is introduced.  The database
+ * is actually one *or more* tables, stored sequentially in the .pag file,
+ * and the length of linear-probe sequences is limited.  The search (for an
+ * existing item or an empty slot) always starts in the first table, and
+ * whenever MAXRUN probes have been done in table N, probing continues in
+ * table N+1.  This behaves reasonably well even in cases of massive
+ * overflow.  There are some other small complications added, see comments
+ * below.
+ * 
  * The table size is fixed for any particular database, but is determined
  * dynamically when a database is rebuilt.  The strategy is to try to pick
  * the size so the first table will be no more than 2/3 full, that being
  * slightly before the point where performance starts to degrade.  (It is
- * desirable to be a bit conservative because the overflow strategy tends
- * to produce files with holes in them, which is a nuisance.)
+ * desirable to be a bit conservative because the overflow strategy tends to
+ * produce files with holes in them, which is a nuisance.)
  */
 
 /*
@@ -112,41 +109,40 @@ static int dbzversion = 3;	/* for validating .dir file format */
 
 /*
  * ANSI C says an offset into a file is a long, not an off_t, for some
- * reason.  This actually does simplify life a bit, but it's still nice
- * to have a distinctive name for it.  Beware, this is just for readability,
+ * reason.  This actually does simplify life a bit, but it's still nice to
+ * have a distinctive name for it.  Beware, this is just for readability,
  * don't try to change this.
  */
 #define	of_t	long
 #define	SOF	(sizeof(of_t))
 
 /*
- * We assume that unused areas of a binary file are zeros, and that the
- * bit pattern of `(of_t)0' is all zeros.  The alternative is rather
- * painful file initialization.  Note that okayvalue(), if OVERFLOW is
- * defined, knows what value of an offset would cause overflow.
+ * We assume that unused areas of a binary file are zeros, and that the bit
+ * pattern of `(of_t)0' is all zeros.  The alternative is rather painful file
+ * initialization.  Note that okayvalue(), if OVERFLOW is defined, knows what
+ * value of an offset would cause overflow.
  */
 #define	VACANT		((of_t)0)
-#define	BIAS(o)		((o)+1)		/* make any valid of_t non-VACANT */
-#define	UNBIAS(o)	((o)-1)		/* reverse BIAS() effect */
+#define	BIAS(o)		((o)+1)	/* make any valid of_t non-VACANT */
+#define	UNBIAS(o)	((o)-1)	/* reverse BIAS() effect */
 
 /*
- * In a Unix implementation, or indeed any in which an of_t is a byte
- * count, there are a bunch of high bits free in an of_t.  There is a
- * use for them.  Checking a possible hit by looking it up in the base
- * file is relatively expensive, and the cost can be dramatically reduced
- * by using some of those high bits to tag the value with a few more bits
- * of the key's hash.  This detects most false hits without the overhead of
- * seek+read+strcmp.  We use the top bit to indicate whether the value is
- * tagged or not, and don't tag a value which is using the tag bits itself.
- * We're in trouble if the of_t representation wants to use the top bit.
- * The actual bitmasks and offset come from the configuration stuff,
- * which permits fiddling with them as necessary, and also suppressing
- * them completely (by defining the masks to 0).  We build pre-shifted
- * versions of the masks for efficiency.
+ * In a Unix implementation, or indeed any in which an of_t is a byte count,
+ * there are a bunch of high bits free in an of_t.  There is a use for them.
+ * Checking a possible hit by looking it up in the base file is relatively
+ * expensive, and the cost can be dramatically reduced by using some of those
+ * high bits to tag the value with a few more bits of the key's hash.  This
+ * detects most false hits without the overhead of seek+read+strcmp.  We use
+ * the top bit to indicate whether the value is tagged or not, and don't tag
+ * a value which is using the tag bits itself. We're in trouble if the of_t
+ * representation wants to use the top bit. The actual bitmasks and offset
+ * come from the configuration stuff, which permits fiddling with them as
+ * necessary, and also suppressing them completely (by defining the masks to
+ * 0).  We build pre-shifted versions of the masks for efficiency.
  */
-static of_t tagbits;		/* pre-shifted tag mask */
-static of_t taghere;		/* pre-shifted tag-enable bit */
-static of_t tagboth;		/* tagbits|taghere */
+static of_t     tagbits;	/* pre-shifted tag mask */
+static of_t     taghere;	/* pre-shifted tag-enable bit */
+static of_t     tagboth;	/* tagbits|taghere */
 #define	HASTAG(o)	((o)&taghere)
 #define	TAG(o)		((o)&tagbits)
 #define	NOTAG(o)	((o)&~tagboth)
@@ -154,9 +150,9 @@ static of_t tagboth;		/* tagbits|taghere */
 #define	MKTAG(v)	(((v)<<conf.tagshift)&tagbits)
 
 /*
- * A new, from-scratch database, not built as a rebuild of an old one,
- * needs to know table size, casemap algorithm, and tagging.  Normally
- * the user supplies this info, but there have to be defaults.
+ * A new, from-scratch database, not built as a rebuild of an old one, needs
+ * to know table size, casemap algorithm, and tagging.  Normally the user
+ * supplies this info, but there have to be defaults.
  */
 #ifndef DEFSIZE
 #define	DEFSIZE	120011		/* 300007 might be better */
@@ -183,42 +179,42 @@ static of_t tagboth;		/* tagbits|taghere */
 #endif
 
 /*
- * We read configuration info from the .dir file into this structure,
- * so we can avoid wired-in assumptions for an existing database.
- *
- * Among the info is a record of recent peak usages, so that a new table
- * size can be chosen intelligently when rebuilding.  10 is a good
- * number of usages to keep, since news displays marked fluctuations
- * in volume on a 7-day cycle.
+ * We read configuration info from the .dir file into this structure, so we
+ * can avoid wired-in assumptions for an existing database.
+ * 
+ * Among the info is a record of recent peak usages, so that a new table size
+ * can be chosen intelligently when rebuilding.  10 is a good number of
+ * usages to keep, since news displays marked fluctuations in volume on a
+ * 7-day cycle.
  */
 struct dbzconfig {
-	int olddbz;		/* .dir file empty but .pag not? */
-	of_t tsize;		/* table size */
-#	ifndef NMEMORY
-#	define	NMEMORY	10	/* # days of use info to remember */
-#	endif
-#	define	NUSEDS	(1+NMEMORY)
-	of_t used[NUSEDS];	/* entries used today, yesterday, ... */
-	int valuesize;		/* size of table values, == SOF */
-	int bytemap[SOF];	/* byte-order map */
-	char casemap;		/* case-mapping algorithm (see cipoint()) */
-	char fieldsep;		/* field separator in base file, if any */
-	of_t tagenb;		/* unshifted tag-enable bit */
-	of_t tagmask;		/* unshifted tag mask */
-	int tagshift;		/* shift count for tagmask and tagenb */
+    int             olddbz;	/* .dir file empty but .pag not? */
+    of_t            tsize;	/* table size */
+#ifndef NMEMORY
+#define	NMEMORY	10		/* # days of use info to remember */
+#endif
+#define	NUSEDS	(1+NMEMORY)
+    of_t            used[NUSEDS];	/* entries used today, yesterday, ... */
+    int             valuesize;	/* size of table values, == SOF */
+    int             bytemap[SOF];	/* byte-order map */
+    char            casemap;	/* case-mapping algorithm (see cipoint()) */
+    char            fieldsep;	/* field separator in base file, if any */
+    of_t            tagenb;	/* unshifted tag-enable bit */
+    of_t            tagmask;	/* unshifted tag mask */
+    int             tagshift;	/* shift count for tagmask and tagenb */
 };
 static struct dbzconfig conf;
-static int getconf();
-static long getno();
-static int putconf();
-static void mybytemap();
-static of_t bytemap();
+static int      getconf();
+static long     getno();
+static int      putconf();
+static void     mybytemap();
+static of_t     bytemap();
 
 /*
  * Using mmap() is a more efficent way of keeping the .pag file incore.  On
- * average, it cuts the number of system calls and buffer copies in half.
- * It also allows one copy to be shared among many processes without
- * consuming any extra resources.
+ * average, it cuts the number of system calls and buffer copies in half. It
+ * also allows one copy to be shared among many processes without consuming
+ * any extra resources.
  */
 #ifdef MMAP
 #include <sys/mman.h>
@@ -232,51 +228,50 @@ static of_t bytemap();
 #endif
 #endif
 
-/* 
- * For a program that makes many, many references to the database, it
- * is a large performance win to keep the table in core, if it will fit.
- * Note that this does hurt robustness in the event of crashes, and
- * dbmclose() *must* be called to flush the in-core database to disk.
- * The code is prepared to deal with the possibility that there isn't
- * enough memory.  There *is* an assumption that a size_t is big enough
- * to hold the size (in bytes) of one table, so dbminit() tries to figure
- * out whether this is possible first.
- *
- * The preferred way to ask for an in-core table is to do dbzincore(1)
- * before dbminit().  The default is not to do it, although -DINCORE
- * overrides this for backward compatibility with old dbz.
- *
- * We keep only the first table in core.  This greatly simplifies the
- * code, and bounds memory demand.  Furthermore, doing this is a large
- * performance win even in the event of massive overflow.
+/*
+ * For a program that makes many, many references to the database, it is a
+ * large performance win to keep the table in core, if it will fit. Note that
+ * this does hurt robustness in the event of crashes, and dbmclose() *must*
+ * be called to flush the in-core database to disk. The code is prepared to
+ * deal with the possibility that there isn't enough memory.  There *is* an
+ * assumption that a size_t is big enough to hold the size (in bytes) of one
+ * table, so dbminit() tries to figure out whether this is possible first.
+ * 
+ * The preferred way to ask for an in-core table is to do dbzincore(1) before
+ * dbminit().  The default is not to do it, although -DINCORE overrides this
+ * for backward compatibility with old dbz.
+ * 
+ * We keep only the first table in core.  This greatly simplifies the code, and
+ * bounds memory demand.  Furthermore, doing this is a large performance win
+ * even in the event of massive overflow.
  */
 #ifdef INCORE
-static int incore = 1;
+static int      incore = 1;
 #else
-static int incore = 0;
+static int      incore = 0;
 #endif
 
 /*
  * Write to filesystem even if incore?  This replaces a single multi-
- * megabyte write when doing a dbzsync with a multi-byte write each
- * time an article is added.  On most systems, this will give an overall
- * performance boost.
+ * megabyte write when doing a dbzsync with a multi-byte write each time an
+ * article is added.  On most systems, this will give an overall performance
+ * boost.
  */
-static int writethrough = 0;
+static int      writethrough = 0;
 
 /*
  * Stdio buffer for .pag reads.  Buffering more than about 16 does not help
  * significantly at the densities we try to maintain, and the much larger
- * buffers that most stdios default to are much more expensive to fill.
- * With small buffers, stdio is performance-competitive with raw read(),
- * and it's much more portable.
+ * buffers that most stdios default to are much more expensive to fill. With
+ * small buffers, stdio is performance-competitive with raw read(), and it's
+ * much more portable.
  */
 #ifndef NPAGBUF
 #define	NPAGBUF	16
 #endif
 #ifndef NOBUFFER
 #ifdef _IOFBF
-static of_t pagbuf[NPAGBUF];	/* only needed if !NOBUFFER && _IOFBF */
+static of_t     pagbuf[NPAGBUF];/* only needed if !NOBUFFER && _IOFBF */
 #endif
 #endif
 
@@ -289,54 +284,53 @@ static of_t pagbuf[NPAGBUF];	/* only needed if !NOBUFFER && _IOFBF */
 #define	SHISTBUF	64
 #endif
 #ifdef _IOFBF
-static char basebuf[SHISTBUF];		/* only needed if _IOFBF exists */
+static char     basebuf[SHISTBUF];	/* only needed if _IOFBF exists */
 #endif
 
 /*
  * Data structure for recording info about searches.
  */
 struct searcher {
-	of_t place;		/* current location in file */
-	int tabno;		/* which table we're in */
-	int run;		/* how long we'll stay in this table */
-#		ifndef MAXRUN
-#		define	MAXRUN	100
-#		endif
-	long hash;		/* the key's hash code (for optimization) */
-	of_t tag;		/* tag we are looking for */
-	int seen;		/* have we examined current location? */
-	int aborted;		/* has i/o error aborted search? */
+    of_t            place;	/* current location in file */
+    int             tabno;	/* which table we're in */
+    int             run;	/* how long we'll stay in this table */
+#ifndef MAXRUN
+#define	MAXRUN	100
+#endif
+    long            hash;	/* the key's hash code (for optimization) */
+    of_t            tag;	/* tag we are looking for */
+    int             seen;	/* have we examined current location? */
+    int             aborted;	/* has i/o error aborted search? */
 };
-static void start();
+static void     start();
 #define	FRESH	((struct searcher *)NULL)
-static of_t search();
+static of_t     search();
 #define	NOTFOUND	((of_t)-1)
-static int okayvalue();
-static int set();
+static int      okayvalue();
+static int      set();
 
 /*
- * Arguably the searcher struct for a given routine ought to be local to
- * it, but a fetch() is very often immediately followed by a store(), and
- * in some circumstances it is a useful performance win to remember where
- * the fetch() completed.  So we use a global struct and remember whether
- * it is current.
+ * Arguably the searcher struct for a given routine ought to be local to it,
+ * but a fetch() is very often immediately followed by a store(), and in some
+ * circumstances it is a useful performance win to remember where the fetch()
+ * completed.  So we use a global struct and remember whether it is current.
  */
 static struct searcher srch;
 static struct searcher *prevp;	/* &srch or FRESH */
 
 /* byte-ordering stuff */
-static int mybmap[SOF];			/* my byte order (see mybytemap()) */
-static int bytesame;			/* is database order same as mine? */
+static int      mybmap[SOF];	/* my byte order (see mybytemap()) */
+static int      bytesame;	/* is database order same as mine? */
 #define	MAPIN(o)	((bytesame) ? (o) : bytemap((o), conf.bytemap, mybmap))
 #define	MAPOUT(o)	((bytesame) ? (o) : bytemap((o), mybmap, conf.bytemap))
 
 /*
  * The double parentheses needed to make this work are ugly, but the
- * alternative (under most compilers) is to pack around 2K of unused
- * strings -- there's just no way to get rid of them.
+ * alternative (under most compilers) is to pack around 2K of unused strings
+ * -- there's just no way to get rid of them.
  */
 #ifdef DBZDEBUG
-static int debug;			/* controlled by dbzdebug() */
+static int      debug;		/* controlled by dbzdebug() */
 #define DEBUG(args) if (debug) { (void) printf args ; } else
 #else
 #define	DEBUG(args)	;
@@ -344,1409 +338,1382 @@ static int debug;			/* controlled by dbzdebug() */
 
 /* externals used */
 #if	0
-extern char *memcpy();
-extern char *memchr();
-extern char *malloc();
-extern char *calloc();
-extern void free();		/* ANSI C; some old implementations say int */
-#endif	/* 0 */
-extern int atoi();
-extern long atol();
-extern void CloseOnExec();
+extern char    *memcpy();
+extern char    *memchr();
+extern char    *malloc();
+extern char    *calloc();
+extern void     free();		/* ANSI C; some old implementations say int */
+#endif				/* 0 */
+extern int      atoi();
+extern long     atol();
+extern void     CloseOnExec();
 
 /* misc. forwards */
-static long hash();
-static void crcinit();
-static char *cipoint();
-static char *mapcase();
-static int isprime();
-static FILE *latebase();
+static long     hash();
+static void     crcinit();
+static char    *cipoint();
+static char    *mapcase();
+static int      isprime();
+static FILE    *latebase();
 
 /* file-naming stuff */
-static char dir[] = ".dir";
-static char pag[] = ".pag";
-static char *enstring();
+static char     dir[] = ".dir";
+static char     pag[] = ".pag";
+static char    *enstring();
 
 /* central data structures */
-static FILE *basef;		/* descriptor for base file */
-static char *basefname;		/* name for not-yet-opened base file */
-static FILE *dirf;		/* descriptor for .dir file */
-static int dirronly;		/* dirf open read-only? */
-static FILE *pagf = NULL;	/* descriptor for .pag file */
-static of_t pagpos;		/* posn in pagf; only search may set != -1 */
-static int pagronly;		/* pagf open read-only? */
-static of_t *corepag;		/* incore version of .pag file, if any */
-static FILE *bufpagf;		/* well-buffered pagf, for incore rewrite */
-static of_t *getcore();
+static FILE    *basef;		/* descriptor for base file */
+static char    *basefname;	/* name for not-yet-opened base file */
+static FILE    *dirf;		/* descriptor for .dir file */
+static int      dirronly;	/* dirf open read-only? */
+static FILE    *pagf = NULL;	/* descriptor for .pag file */
+static of_t     pagpos;		/* posn in pagf; only search may set != -1 */
+static int      pagronly;	/* pagf open read-only? */
+static of_t    *corepag;	/* incore version of .pag file, if any */
+static FILE    *bufpagf;	/* well-buffered pagf, for incore rewrite */
+static of_t    *getcore();
 #ifndef MMAP
-static int putcore();
+static int      putcore();
 #endif
-static int written;		/* has a store() been done? */
+static int      written;	/* has a store() been done? */
 
 /*
- - dbzfresh - set up a new database, no historical info
+ * - dbzfresh - set up a new database, no historical info
  */
 int				/* 0 success, -1 failure */
 dbzfresh(name, size, fs, cmap, tagmask)
-char *name;			/* base name; .dir and .pag must exist */
-long size;			/* table size (0 means default) */
-int fs;				/* field-separator character in base file */
-int cmap;			/* case-map algorithm (0 means default) */
-of_t tagmask;			/* 0 default, 1 no tags */
+    char           *name;	/* base name; .dir and .pag must exist */
+    long            size;	/* table size (0 means default) */
+    int             fs;		/* field-separator character in base file */
+    int             cmap;	/* case-map algorithm (0 means default) */
+    of_t            tagmask;	/* 0 default, 1 no tags */
 {
-	register char *fn;
-	struct dbzconfig c;
-	register of_t m;
-	register FILE *f;
-
-	if (pagf != NULL) {
-		DEBUG(("dbzfresh: database already open\n"));
-		return(-1);
-	}
-	if (size != 0 && size < 2) {
-		DEBUG(("dbzfresh: preposterous size (%ld)\n", size));
-		return(-1);
-	}
-
-	/* get default configuration */
-	if (getconf((FILE *)NULL, (FILE *)NULL, &c) < 0)
-		return(-1);	/* "can't happen" */
-
-	/* and mess with it as specified */
-	if (size != 0)
-		c.tsize = size;
-	c.fieldsep = fs;
-	switch (cmap) {
-	case 0:
-	case '0':
-	case 'B':		/* 2.10 compat */
-		c.casemap = '0';	/* '\0' nicer, but '0' printable! */
-		break;
-	case '=':
-	case 'b':		/* 2.11 compat */
-		c.casemap = '=';
-		break;
-	case 'C':
-		c.casemap = 'C';
-		break;
-	case '?':
-		c.casemap = DEFCASE;
-		break;
-	default:
-		DEBUG(("dbzfresh case map `%c' unknown\n", cmap));
-		return(-1);
-	}
-	switch ((int)tagmask) {
-	case 0:			/* default */
-		break;
-	case 1:			/* no tags */
-		c.tagshift = 0;
-		c.tagmask = 0;
-		c.tagenb = 0;
-		break;
-	default:
-		m = tagmask;
-		c.tagshift = 0;
-		while (!(m&01)) {
-			m >>= 1;
-			c.tagshift++;
-		}
-		c.tagmask = m;
-		c.tagenb = (m << 1) & ~m;
-		break;
-	}
-
-	/* write it out */
-	fn = enstring(name, dir);
-	if (fn == NULL)
-		return(-1);
-	f = fopen(fn, "w");
-	free((POINTER)fn);
-	if (f == NULL) {
-		DEBUG(("dbzfresh: unable to write config\n"));
-		return(-1);
-	}
-	if (putconf(f, &c) < 0) {
-		(void) fclose(f);
-		return(-1);
-	}
-	if (fclose(f) == EOF) {
-		DEBUG(("dbzfresh: fclose failure\n"));
-		return(-1);
-	}
-
-	/* create/truncate .pag */
-	fn = enstring(name, pag);
-	if (fn == NULL)
-		return(-1);
-	f = fopen(fn, "w");
-	free((POINTER)fn);
-	if (f == NULL) {
-		DEBUG(("dbzfresh: unable to create/truncate .pag file\n"));
-		return(-1);
-	} else
-		(void) fclose(f);
-
-	/* and punt to dbminit for the hard work */
-	return(dbminit(name));
+    register char  *fn;
+    struct dbzconfig c;
+    register of_t   m;
+    register FILE  *f;
+
+    if (pagf != NULL) {
+	DEBUG(("dbzfresh: database already open\n"));
+	return (-1);
+    }
+    if (size != 0 && size < 2) {
+	DEBUG(("dbzfresh: preposterous size (%ld)\n", size));
+	return (-1);
+    }
+    /* get default configuration */
+    if (getconf((FILE *) NULL, (FILE *) NULL, &c) < 0)
+	return (-1);		/* "can't happen" */
+
+    /* and mess with it as specified */
+    if (size != 0)
+	c.tsize = size;
+    c.fieldsep = fs;
+    switch (cmap) {
+    case 0:
+    case '0':
+    case 'B':			/* 2.10 compat */
+	c.casemap = '0';	/* '\0' nicer, but '0' printable! */
+	break;
+    case '=':
+    case 'b':			/* 2.11 compat */
+	c.casemap = '=';
+	break;
+    case 'C':
+	c.casemap = 'C';
+	break;
+    case '?':
+	c.casemap = DEFCASE;
+	break;
+    default:
+	DEBUG(("dbzfresh case map `%c' unknown\n", cmap));
+	return (-1);
+    }
+    switch ((int)tagmask) {
+    case 0:			/* default */
+	break;
+    case 1:			/* no tags */
+	c.tagshift = 0;
+	c.tagmask = 0;
+	c.tagenb = 0;
+	break;
+    default:
+	m = tagmask;
+	c.tagshift = 0;
+	while (!(m & 01)) {
+	    m >>= 1;
+	    c.tagshift++;
+	}
+	c.tagmask = m;
+	c.tagenb = (m << 1) & ~m;
+	break;
+    }
+
+    /* write it out */
+    fn = enstring(name, dir);
+    if (fn == NULL)
+	return (-1);
+    f = fopen(fn, "w");
+    free((POINTER) fn);
+    if (f == NULL) {
+	DEBUG(("dbzfresh: unable to write config\n"));
+	return (-1);
+    }
+    if (putconf(f, &c) < 0) {
+	(void)fclose(f);
+	return (-1);
+    }
+    if (fclose(f) == EOF) {
+	DEBUG(("dbzfresh: fclose failure\n"));
+	return (-1);
+    }
+    /* create/truncate .pag */
+    fn = enstring(name, pag);
+    if (fn == NULL)
+	return (-1);
+    f = fopen(fn, "w");
+    free((POINTER) fn);
+    if (f == NULL) {
+	DEBUG(("dbzfresh: unable to create/truncate .pag file\n"));
+	return (-1);
+    } else
+	(void)fclose(f);
+
+    /* and punt to dbminit for the hard work */
+    return (dbminit(name));
 }
 
 /*
- - dbzsize - what's a good table size to hold this many entries?
+ * - dbzsize - what's a good table size to hold this many entries?
  */
 long
 dbzsize(contents)
-long contents;			/* 0 means what's the default */
+    long            contents;	/* 0 means what's the default */
 {
-	register long n;
-
-	if (contents <= 0) {	/* foulup or default inquiry */
-		DEBUG(("dbzsize: preposterous input (%ld)\n", contents));
-		return(DEFSIZE);
-	}
-	n = (contents/2)*3;	/* try to keep table at most 2/3 full */
-	if (!(n&01))		/* make it odd */
-		n++;
-	DEBUG(("dbzsize: tentative size %ld\n", n));
-	while (!isprime(n))	/* and look for a prime */
-		n += 2;
-	DEBUG(("dbzsize: final size %ld\n", n));
-
-	return(n);
+    register long   n;
+
+    if (contents <= 0) {	/* foulup or default inquiry */
+	DEBUG(("dbzsize: preposterous input (%ld)\n", contents));
+	return (DEFSIZE);
+    }
+    n = (contents / 2) * 3;	/* try to keep table at most 2/3 full */
+    if (!(n & 01))		/* make it odd */
+	n++;
+    DEBUG(("dbzsize: tentative size %ld\n", n));
+    while (!isprime(n))		/* and look for a prime */
+	n += 2;
+    DEBUG(("dbzsize: final size %ld\n", n));
+
+    return (n);
 }
 
 /*
- - isprime - is a number prime?
- *
+ * - isprime - is a number prime?
+ * 
  * This is not a terribly efficient approach.
  */
 static int			/* predicate */
 isprime(x)
-register long x;
+    register long   x;
 {
-	static int quick[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 0 };
-	register int *ip;
-	register long div;
-	register long stop;
-
-	/* hit the first few primes quickly to eliminate easy ones */
-	/* this incidentally prevents ridiculously small tables */
-	for (ip = quick; (div = *ip) != 0; ip++)
-		if (x%div == 0) {
-			DEBUG(("isprime: quick result on %ld\n", (long)x));
-			return(0);
-		}
-
-	/* approximate square root of x */
-	for (stop = x; x/stop < stop; stop >>= 1)
-		continue;
-	stop <<= 1;
-
-	/* try odd numbers up to stop */
-	for (div = *--ip; div < stop; div += 2)
-		if (x%div == 0)
-			return(0);
-
-	return(1);
+    static int      quick[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 0};
+    register int   *ip;
+    register long   div;
+    register long   stop;
+
+    /* hit the first few primes quickly to eliminate easy ones */
+    /* this incidentally prevents ridiculously small tables */
+    for (ip = quick; (div = *ip) != 0; ip++)
+	if (x % div == 0) {
+	    DEBUG(("isprime: quick result on %ld\n", (long)x));
+	    return (0);
+	}
+    /* approximate square root of x */
+    for (stop = x; x / stop < stop; stop >>= 1)
+	continue;
+    stop <<= 1;
+
+    /* try odd numbers up to stop */
+    for (div = *--ip; div < stop; div += 2)
+	if (x % div == 0)
+	    return (0);
+
+    return (1);
 }
 
 /*
- - dbzagain - set up a new database to be a rebuild of an old one
+ * - dbzagain - set up a new database to be a rebuild of an old one
  */
 int				/* 0 success, -1 failure */
 dbzagain(name, oldname)
-char *name;			/* base name; .dir and .pag must exist */
-char *oldname;			/* base name; all must exist */
+    char           *name;	/* base name; .dir and .pag must exist */
+    char           *oldname;	/* base name; all must exist */
 {
-	register char *fn;
-	struct dbzconfig c;
-	register int i;
-	register long top;
-	register FILE *f;
-	register int newtable;
-	register of_t newsize;
-	struct stat sb;
-	register of_t m;
-
-	if (pagf != NULL) {
-		DEBUG(("dbzagain: database already open\n"));
-		return(-1);
-	}
-
-	/* pick up the old configuration */
-	fn = enstring(oldname, dir);
-	if (fn == NULL)
-		return(-1);
-	f = fopen(fn, "r");
-	free((POINTER)fn);
-	if (f == NULL) {
-		DEBUG(("dbzagain: cannot open old .dir file\n"));
-		return(-1);
-	}
-	i = getconf(f, (FILE *)NULL, &c);
-	(void) fclose(f);
-	if (i < 0) {
-		DEBUG(("dbzagain: getconf failed\n"));
-		return(-1);
-	}
-
-	/* calculate tagging from old file */
-	if (stat(oldname, &sb) != -1) {
-		 for (m = 1, i = 0; m < sb.st_size; i++, m <<= 1)
-			 continue;
-		 
-		 /* if we had more tags than the default, use the new data */
-		 if ((c.tagmask | c.tagenb) && m > (1 << TAGSHIFT)) {
-			  c.tagshift = i;
-			  c.tagmask = (~(unsigned long)0) >> (i + 1);
-			  c.tagenb = (c.tagmask << 1) & ~c.tagmask;
-		 }
-	}
-
-	/* tinker with it */
-	top = 0;
-	newtable = 0;
-	for (i = 0; i < NUSEDS; i++) {
-		if (top < c.used[i])
-			top = c.used[i];
-		if (c.used[i] == 0)
-			newtable = 1;	/* hasn't got full usage history yet */
-	}
-	if (top == 0) {
-		DEBUG(("dbzagain: old table has no contents!\n"));
-		newtable = 1;
-	}
-	for (i = NUSEDS-1; i > 0; i--)
-		c.used[i] = c.used[i-1];
-	c.used[0] = 0;
-	newsize = dbzsize(top);
-	if (!newtable || newsize > c.tsize)	/* don't shrink new table */
-		c.tsize = newsize;
-
-	/* write it out */
-	fn = enstring(name, dir);
-	if (fn == NULL)
-		return(-1);
-	f = fopen(fn, "w");
-	free((POINTER)fn);
-	if (f == NULL) {
-		DEBUG(("dbzagain: unable to write new .dir\n"));
-		return(-1);
-	}
-	i = putconf(f, &c);
-	(void) fclose(f);
-	if (i < 0) {
-		DEBUG(("dbzagain: putconf failed\n"));
-		return(-1);
-	}
-
-	/* create/truncate .pag */
-	fn = enstring(name, pag);
-	if (fn == NULL)
-		return(-1);
-	f = fopen(fn, "w");
-	free((POINTER)fn);
-	if (f == NULL) {
-		DEBUG(("dbzagain: unable to create/truncate .pag file\n"));
-		return(-1);
-	} else
-		(void) fclose(f);
-
-	/* and let dbminit do the work */
-	return(dbminit(name));
+    register char  *fn;
+    struct dbzconfig c;
+    register int    i;
+    register long   top;
+    register FILE  *f;
+    register int    newtable;
+    register of_t   newsize;
+    struct stat     sb;
+    register of_t   m;
+
+    if (pagf != NULL) {
+	DEBUG(("dbzagain: database already open\n"));
+	return (-1);
+    }
+    /* pick up the old configuration */
+    fn = enstring(oldname, dir);
+    if (fn == NULL)
+	return (-1);
+    f = fopen(fn, "r");
+    free((POINTER) fn);
+    if (f == NULL) {
+	DEBUG(("dbzagain: cannot open old .dir file\n"));
+	return (-1);
+    }
+    i = getconf(f, (FILE *) NULL, &c);
+    (void)fclose(f);
+    if (i < 0) {
+	DEBUG(("dbzagain: getconf failed\n"));
+	return (-1);
+    }
+    /* calculate tagging from old file */
+    if (stat(oldname, &sb) != -1) {
+	for (m = 1, i = 0; m < sb.st_size; i++, m <<= 1)
+	    continue;
+
+	/* if we had more tags than the default, use the new data */
+	if ((c.tagmask | c.tagenb) && m > (1 << TAGSHIFT)) {
+	    c.tagshift = i;
+	    c.tagmask = (~(unsigned long)0) >> (i + 1);
+	    c.tagenb = (c.tagmask << 1) & ~c.tagmask;
+	}
+    }
+    /* tinker with it */
+    top = 0;
+    newtable = 0;
+    for (i = 0; i < NUSEDS; i++) {
+	if (top < c.used[i])
+	    top = c.used[i];
+	if (c.used[i] == 0)
+	    newtable = 1;	/* hasn't got full usage history yet */
+    }
+    if (top == 0) {
+	DEBUG(("dbzagain: old table has no contents!\n"));
+	newtable = 1;
+    }
+    for (i = NUSEDS - 1; i > 0; i--)
+	c.used[i] = c.used[i - 1];
+    c.used[0] = 0;
+    newsize = dbzsize(top);
+    if (!newtable || newsize > c.tsize)	/* don't shrink new table */
+	c.tsize = newsize;
+
+    /* write it out */
+    fn = enstring(name, dir);
+    if (fn == NULL)
+	return (-1);
+    f = fopen(fn, "w");
+    free((POINTER) fn);
+    if (f == NULL) {
+	DEBUG(("dbzagain: unable to write new .dir\n"));
+	return (-1);
+    }
+    i = putconf(f, &c);
+    (void)fclose(f);
+    if (i < 0) {
+	DEBUG(("dbzagain: putconf failed\n"));
+	return (-1);
+    }
+    /* create/truncate .pag */
+    fn = enstring(name, pag);
+    if (fn == NULL)
+	return (-1);
+    f = fopen(fn, "w");
+    free((POINTER) fn);
+    if (f == NULL) {
+	DEBUG(("dbzagain: unable to create/truncate .pag file\n"));
+	return (-1);
+    } else
+	(void)fclose(f);
+
+    /* and let dbminit do the work */
+    return (dbminit(name));
 }
 
 /*
- - dbminit - open a database, creating it (using defaults) if necessary
- *
- * We try to leave errno set plausibly, to the extent that underlying
- * functions permit this, since many people consult it if dbminit() fails.
+ * - dbminit - open a database, creating it (using defaults) if necessary
+ * 
+ * We try to leave errno set plausibly, to the extent that underlying functions
+ * permit this, since many people consult it if dbminit() fails.
  */
-int 				/* 0 success, -1 failure */
+int				/* 0 success, -1 failure */
 dbminit(name)
-char *name;
+    char           *name;
 {
-	register int i;
-	register size_t s;
-	register char *dirfname;
-	register char *pagfname;
-
-	if (pagf != NULL) {
-		DEBUG(("dbminit: dbminit already called once\n"));
-		errno = 0;
-		return(-1);
-	}
-
-	/* open the .dir file */
-	dirfname = enstring(name, dir);
-	if (dirfname == NULL)
-		return(-1);
-	dirf = fopen(dirfname, "r+");
-	if (dirf == NULL) {
-		dirf = fopen(dirfname, "r");
-		dirronly = 1;
-	} else
-		dirronly = 0;
-	free((POINTER)dirfname);
-	if (dirf == NULL) {
-		DEBUG(("dbminit: can't open .dir file\n"));
-		return(-1);
-	}
-	CloseOnExec((int)fileno(dirf), 1);
-
-	/* open the .pag file */
-	pagfname = enstring(name, pag);
-	if (pagfname == NULL) {
-		(void) fclose(dirf);
-		return(-1);
-	}
-	pagf = fopen(pagfname, "r+b");
+    register int    i;
+    register size_t s;
+    register char  *dirfname;
+    register char  *pagfname;
+
+    if (pagf != NULL) {
+	DEBUG(("dbminit: dbminit already called once\n"));
+	errno = 0;
+	return (-1);
+    }
+    /* open the .dir file */
+    dirfname = enstring(name, dir);
+    if (dirfname == NULL)
+	return (-1);
+    dirf = fopen(dirfname, "r+");
+    if (dirf == NULL) {
+	dirf = fopen(dirfname, "r");
+	dirronly = 1;
+    } else
+	dirronly = 0;
+    free((POINTER) dirfname);
+    if (dirf == NULL) {
+	DEBUG(("dbminit: can't open .dir file\n"));
+	return (-1);
+    }
+    CloseOnExec((int)fileno(dirf), 1);
+
+    /* open the .pag file */
+    pagfname = enstring(name, pag);
+    if (pagfname == NULL) {
+	(void)fclose(dirf);
+	return (-1);
+    }
+    pagf = fopen(pagfname, "r+b");
+    if (pagf == NULL) {
+	pagf = fopen(pagfname, "rb");
 	if (pagf == NULL) {
-		pagf = fopen(pagfname, "rb");
-		if (pagf == NULL) {
-			DEBUG(("dbminit: .pag open failed\n"));
-			(void) fclose(dirf);
-			free((POINTER)pagfname);
-			return(-1);
-		}
-		pagronly = 1;
-	} else if (dirronly)
-		pagronly = 1;
-	else
-		pagronly = 0;
-	if (pagf != NULL)
-		CloseOnExec((int)fileno(pagf), 1);
+	    DEBUG(("dbminit: .pag open failed\n"));
+	    (void)fclose(dirf);
+	    free((POINTER) pagfname);
+	    return (-1);
+	}
+	pagronly = 1;
+    } else if (dirronly)
+	pagronly = 1;
+    else
+	pagronly = 0;
+    if (pagf != NULL)
+	CloseOnExec((int)fileno(pagf), 1);
 #ifdef NOBUFFER
-	/*
-	 * B News does not do adequate locking on its database accesses.
-	 * Why it doesn't get into trouble using dbm is a mystery.  In any
-	 * case, doing unbuffered i/o does not cure the problem, but does
-	 * enormously reduce its incidence.
-	 */
-	(void) setbuf(pagf, (char *)NULL);
+    /*
+     * B News does not do adequate locking on its database accesses. Why it
+     * doesn't get into trouble using dbm is a mystery.  In any case, doing
+     * unbuffered i/o does not cure the problem, but does enormously reduce
+     * its incidence.
+     */
+    (void)setbuf(pagf, (char *)NULL);
 #else
 #ifdef _IOFBF
-	(void) setvbuf(pagf, (char *)pagbuf, _IOFBF, sizeof(pagbuf));
+    (void)setvbuf(pagf, (char *)pagbuf, _IOFBF, sizeof(pagbuf));
 #endif
 #endif
-	pagpos = -1;
-	/* don't free pagfname, need it below */
-
-	/* open the base file */
-	basef = fopen(name, "r");
-	if (basef == NULL) {
-		DEBUG(("dbminit: basefile open failed\n"));
-		basefname = enstring(name, "");
-		if (basefname == NULL) {
-			(void) fclose(pagf);
-			(void) fclose(dirf);
-			free((POINTER)pagfname);
-			pagf = NULL;
-			return(-1);
-		}
-	} else
-		basefname = NULL;
-	if (basef != NULL)
-		CloseOnExec((int)fileno(basef), 1);
+    pagpos = -1;
+    /* don't free pagfname, need it below */
+
+    /* open the base file */
+    basef = fopen(name, "r");
+    if (basef == NULL) {
+	DEBUG(("dbminit: basefile open failed\n"));
+	basefname = enstring(name, "");
+	if (basefname == NULL) {
+	    (void)fclose(pagf);
+	    (void)fclose(dirf);
+	    free((POINTER) pagfname);
+	    pagf = NULL;
+	    return (-1);
+	}
+    } else
+	basefname = NULL;
+    if (basef != NULL)
+	CloseOnExec((int)fileno(basef), 1);
 #ifdef _IOFBF
-	if (basef != NULL)
-		(void) setvbuf(basef, basebuf, _IOFBF, sizeof(basebuf));
+    if (basef != NULL)
+	(void)setvbuf(basef, basebuf, _IOFBF, sizeof(basebuf));
 #endif
 
-	/* pick up configuration */
-	if (getconf(dirf, pagf, &conf) < 0) {
-		DEBUG(("dbminit: getconf failure\n"));
-		(void) fclose(basef);
-		(void) fclose(pagf);
-		(void) fclose(dirf);
-		free((POINTER)pagfname);
-		pagf = NULL;
-		errno = EDOM;	/* kind of a kludge, but very portable */
-		return(-1);
-	}
-	tagbits = conf.tagmask << conf.tagshift;
-	taghere = conf.tagenb << conf.tagshift;
-	tagboth = tagbits | taghere;
-	mybytemap(mybmap);
-	bytesame = 1;
-	for (i = 0; i < SOF; i++)
-		if (mybmap[i] != conf.bytemap[i])
-			bytesame = 0;
-
-	/* get first table into core, if it looks desirable and feasible */
-	s = (size_t)conf.tsize * SOF;
-	if (incore && (of_t)(s/SOF) == conf.tsize) {
-		bufpagf = fopen(pagfname, (pagronly) ? "rb" : "r+b");
-		if (bufpagf != NULL) {
-			corepag = getcore(bufpagf);
-			CloseOnExec((int)fileno(bufpagf), 1);
-		}
-	} else {
-		bufpagf = NULL;
-		corepag = NULL;
-	}
-	free((POINTER)pagfname);
-
-	/* misc. setup */
-	crcinit();
-	written = 0;
-	prevp = FRESH;
-	DEBUG(("dbminit: succeeded\n"));
-	return(0);
+    /* pick up configuration */
+    if (getconf(dirf, pagf, &conf) < 0) {
+	DEBUG(("dbminit: getconf failure\n"));
+	(void)fclose(basef);
+	(void)fclose(pagf);
+	(void)fclose(dirf);
+	free((POINTER) pagfname);
+	pagf = NULL;
+	errno = EDOM;		/* kind of a kludge, but very portable */
+	return (-1);
+    }
+    tagbits = conf.tagmask << conf.tagshift;
+    taghere = conf.tagenb << conf.tagshift;
+    tagboth = tagbits | taghere;
+    mybytemap(mybmap);
+    bytesame = 1;
+    for (i = 0; i < SOF; i++)
+	if (mybmap[i] != conf.bytemap[i])
+	    bytesame = 0;
+
+    /* get first table into core, if it looks desirable and feasible */
+    s = (size_t) conf.tsize * SOF;
+    if (incore && (of_t) (s / SOF) == conf.tsize) {
+	bufpagf = fopen(pagfname, (pagronly) ? "rb" : "r+b");
+	if (bufpagf != NULL) {
+	    corepag = getcore(bufpagf);
+	    CloseOnExec((int)fileno(bufpagf), 1);
+	}
+    } else {
+	bufpagf = NULL;
+	corepag = NULL;
+    }
+    free((POINTER) pagfname);
+
+    /* misc. setup */
+    crcinit();
+    written = 0;
+    prevp = FRESH;
+    DEBUG(("dbminit: succeeded\n"));
+    return (0);
 }
 
 /*
- - enstring - concatenate two strings into a malloced area
+ * - enstring - concatenate two strings into a malloced area
  */
-static char *			/* NULL if malloc fails */
+static char    *		/* NULL if malloc fails */
 enstring(s1, s2)
-char *s1;
-char *s2;
+    char           *s1;
+    char           *s2;
 {
-	register char *p;
-
-	p = malloc((size_t)strlen(s1) + (size_t)strlen(s2) + 1);
-	if (p != NULL) {
-		(void) strcpy(p, s1);
-		(void) strcat(p, s2);
-	} else {
-		DEBUG(("enstring(%s, %s) out of memory\n", s1, s2));
-	}
-	return(p);
+    register char  *p;
+
+    p = malloc((size_t) strlen(s1) + (size_t) strlen(s2) + 1);
+    if (p != NULL) {
+	(void)strcpy(p, s1);
+	(void)strcat(p, s2);
+    } else {
+	DEBUG(("enstring(%s, %s) out of memory\n", s1, s2));
+    }
+    return (p);
 }
 
 /*
- - dbmclose - close a database
+ * - dbmclose - close a database
  */
 int
 dbmclose()
 {
-	register int ret = 0;
-
-	if (pagf == NULL) {
-		DEBUG(("dbmclose: not opened!\n"));
-		return(-1);
-	}
-
-	if (fclose(pagf) == EOF) {
-		DEBUG(("dbmclose: fclose(pagf) failed\n"));
-		ret = -1;
-	}
-	pagf = basef;		/* ensure valid pointer; dbzsync checks it */
-	if (dbzsync() < 0)
-		ret = -1;
-	if (bufpagf != NULL && fclose(bufpagf) == EOF) {
-		DEBUG(("dbmclose: fclose(bufpagf) failed\n"));
-		ret = -1;
-	}
-	if (corepag != NULL)
+    register int    ret = 0;
+
+    if (pagf == NULL) {
+	DEBUG(("dbmclose: not opened!\n"));
+	return (-1);
+    }
+    if (fclose(pagf) == EOF) {
+	DEBUG(("dbmclose: fclose(pagf) failed\n"));
+	ret = -1;
+    }
+    pagf = basef;		/* ensure valid pointer; dbzsync checks it */
+    if (dbzsync() < 0)
+	ret = -1;
+    if (bufpagf != NULL && fclose(bufpagf) == EOF) {
+	DEBUG(("dbmclose: fclose(bufpagf) failed\n"));
+	ret = -1;
+    }
+    if (corepag != NULL)
 #ifdef MMAP
-		if (munmap((caddr_t)corepag, (int)conf.tsize * SOF) == -1) {
-			DEBUG(("dbmclose: munmap failed\n"));
-			ret = -1;
-		}
+	if (munmap((caddr_t) corepag, (int)conf.tsize * SOF) == -1) {
+	    DEBUG(("dbmclose: munmap failed\n"));
+	    ret = -1;
+	}
 #else
-		free((POINTER)corepag);
+	free((POINTER) corepag);
 #endif
-	corepag = NULL;
-	if (basef) {
-	  if (fclose(basef) == EOF) {
-		DEBUG(("dbmclose: fclose(basef) failed\n"));
-		ret = -1;
-	  }
-	}
-	if (basefname != NULL)
-		free((POINTER)basefname);
-	basef = NULL;
-	pagf = NULL;
-	if (fclose(dirf) == EOF) {
-		DEBUG(("dbmclose: fclose(dirf) failed\n"));
-		ret = -1;
-	}
-
-	DEBUG(("dbmclose: %s\n", (ret == 0) ? "succeeded" : "failed"));
-	return(ret);
+    corepag = NULL;
+    if (basef) {
+	if (fclose(basef) == EOF) {
+	    DEBUG(("dbmclose: fclose(basef) failed\n"));
+	    ret = -1;
+	}
+    }
+    if (basefname != NULL)
+	free((POINTER) basefname);
+    basef = NULL;
+    pagf = NULL;
+    if (fclose(dirf) == EOF) {
+	DEBUG(("dbmclose: fclose(dirf) failed\n"));
+	ret = -1;
+    }
+    DEBUG(("dbmclose: %s\n", (ret == 0) ? "succeeded" : "failed"));
+    return (ret);
 }
 
 /*
- - dbzsync - push all in-core data out to disk
+ * - dbzsync - push all in-core data out to disk
  */
 int
 dbzsync()
 {
-	register int ret = 0;
+    register int    ret = 0;
 
-	if (pagf == NULL) {
-		DEBUG(("dbzsync: not opened!\n"));
-		return(-1);
-	}
-	if (!written)
-		return(0);
+    if (pagf == NULL) {
+	DEBUG(("dbzsync: not opened!\n"));
+	return (-1);
+    }
+    if (!written)
+	return (0);
 
 #ifndef MMAP
-	if (corepag != NULL && !writethrough) {
-		if (putcore(corepag, bufpagf) < 0) {
-			DEBUG(("dbzsync: putcore failed\n"));
-			ret = -1;
-		}
+    if (corepag != NULL && !writethrough) {
+	if (putcore(corepag, bufpagf) < 0) {
+	    DEBUG(("dbzsync: putcore failed\n"));
+	    ret = -1;
 	}
+    }
 #endif
-	if (!conf.olddbz)
-		if (putconf(dirf, &conf) < 0)
-			ret = -1;
+    if (!conf.olddbz)
+	if (putconf(dirf, &conf) < 0)
+	    ret = -1;
 
-	DEBUG(("dbzsync: %s\n", (ret == 0) ? "succeeded" : "failed"));
-	return(ret);
+    DEBUG(("dbzsync: %s\n", (ret == 0) ? "succeeded" : "failed"));
+    return (ret);
 }
 
 /*
- - dbzcancel - cancel writing of in-core data
- * Mostly for use from child processes.
- * Note that we don't need to futz around with stdio buffers, because we
- * always fflush them immediately anyway and so they never have stale data.
+ * - dbzcancel - cancel writing of in-core data Mostly for use from child
+ * processes. Note that we don't need to futz around with stdio buffers,
+ * because we always fflush them immediately anyway and so they never have
+ * stale data.
  */
 int
 dbzcancel()
 {
-	if (pagf == NULL) {
-		DEBUG(("dbzcancel: not opened!\n"));
-		return(-1);
-	}
-
-	written = 0;
-	return(0);
+    if (pagf == NULL) {
+	DEBUG(("dbzcancel: not opened!\n"));
+	return (-1);
+    }
+    written = 0;
+    return (0);
 }
 
 /*
- - dbzfetch - fetch() with case mapping built in
+ * - dbzfetch - fetch() with case mapping built in
  */
 datum
 dbzfetch(key)
-datum key;
+    datum           key;
 {
-	char buffer[DBZMAXKEY + 1];
-	datum mappedkey;
-	register size_t keysize;
-
-	DEBUG(("dbzfetch: (%s)\n", key.dptr));
-
-	/* Key is supposed to be less than DBZMAXKEY */
-	keysize = key.dsize;
-	if (keysize >= DBZMAXKEY) {
-		keysize = DBZMAXKEY;
-		DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
-	}
-
-	mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
-	buffer[keysize] = '\0';	/* just a debug aid */
-	mappedkey.dsize = keysize;
-
-	return(fetch(mappedkey));
+    char            buffer[DBZMAXKEY + 1];
+    datum           mappedkey;
+    register size_t keysize;
+
+    DEBUG(("dbzfetch: (%s)\n", key.dptr));
+
+    /* Key is supposed to be less than DBZMAXKEY */
+    keysize = key.dsize;
+    if (keysize >= DBZMAXKEY) {
+	keysize = DBZMAXKEY;
+	DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
+    }
+    mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
+    buffer[keysize] = '\0';	/* just a debug aid */
+    mappedkey.dsize = keysize;
+
+    return (fetch(mappedkey));
 }
 
 /*
- - fetch - get an entry from the database
- *
- * Disgusting fine point, in the name of backward compatibility:  if the
- * last character of "key" is a NUL, that character is (effectively) not
- * part of the comparison against the stored keys.
+ * - fetch - get an entry from the database
+ * 
+ * Disgusting fine point, in the name of backward compatibility:  if the last
+ * character of "key" is a NUL, that character is (effectively) not part of
+ * the comparison against the stored keys.
  */
 datum				/* dptr NULL, dsize 0 means failure */
 fetch(key)
-datum key;
+    datum           key;
 {
-	char buffer[DBZMAXKEY + 1];
-	static of_t key_ptr;		/* return value points here */
-	datum output;
-	register size_t keysize;
-	register size_t cmplen;
-	register char *sepp;
-
-	DEBUG(("fetch: (%s)\n", key.dptr));
-	output.dptr = NULL;
-	output.dsize = 0;
-	prevp = FRESH;
-
-	/* Key is supposed to be less than DBZMAXKEY */
-	keysize = key.dsize;
-	if (keysize >= DBZMAXKEY) {
-		keysize = DBZMAXKEY;
-		DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
-	}
-
-	if (pagf == NULL) {
-		DEBUG(("fetch: database not open!\n"));
-		return(output);
-	} else if (basef == NULL) {	/* basef didn't exist yet */
-		basef = latebase();
-		if (basef == NULL)
-			return(output);
-	}
-
-	cmplen = keysize;
-	sepp = &conf.fieldsep;
-	if (key.dptr[keysize-1] == '\0') {
-		cmplen--;
-		sepp = &buffer[keysize-1];
-	}
-	start(&srch, &key, FRESH);
-	while ((key_ptr = search(&srch)) != NOTFOUND) {
-		DEBUG(("got 0x%lx\n", key_ptr));
-
-		/* fetch the key */
-		if (fseek(basef, key_ptr, SEEK_SET) != 0) {
-			DEBUG(("fetch: seek failed\n"));
-			return(output);
-		}
-		if (fread((POINTER)buffer, 1, keysize, basef) != keysize) {
-			DEBUG(("fetch: read failed\n"));
-			return(output);
-		}
-
-		/* try it */
-		buffer[keysize] = '\0';		/* terminated for DEBUG */
-		(void) mapcase(buffer, buffer, keysize);
-		DEBUG(("fetch: buffer (%s) looking for (%s) size = %d\n", 
-						buffer, key.dptr, keysize));
-		if (memcmp((POINTER)key.dptr, (POINTER)buffer, cmplen) == 0 &&
-				(*sepp == conf.fieldsep || *sepp == '\0')) {
-			/* we found it */
-			output.dptr = (char *)&key_ptr;
-			output.dsize = SOF;
-			DEBUG(("fetch: successful\n"));
-			return(output);
-		}
-	}
-
-	/* we didn't find it */
-	DEBUG(("fetch: failed\n"));
-	prevp = &srch;			/* remember where we stopped */
-	return(output);
+    char            buffer[DBZMAXKEY + 1];
+    static of_t     key_ptr;	/* return value points here */
+    datum           output;
+    register size_t keysize;
+    register size_t cmplen;
+    register char  *sepp;
+
+    DEBUG(("fetch: (%s)\n", key.dptr));
+    output.dptr = NULL;
+    output.dsize = 0;
+    prevp = FRESH;
+
+    /* Key is supposed to be less than DBZMAXKEY */
+    keysize = key.dsize;
+    if (keysize >= DBZMAXKEY) {
+	keysize = DBZMAXKEY;
+	DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
+    }
+    if (pagf == NULL) {
+	DEBUG(("fetch: database not open!\n"));
+	return (output);
+    } else if (basef == NULL) {	/* basef didn't exist yet */
+	basef = latebase();
+	if (basef == NULL)
+	    return (output);
+    }
+    cmplen = keysize;
+    sepp = &conf.fieldsep;
+    if (key.dptr[keysize - 1] == '\0') {
+	cmplen--;
+	sepp = &buffer[keysize - 1];
+    }
+    start(&srch, &key, FRESH);
+    while ((key_ptr = search(&srch)) != NOTFOUND) {
+	DEBUG(("got 0x%lx\n", key_ptr));
+
+	/* fetch the key */
+	if (fseek(basef, key_ptr, SEEK_SET) != 0) {
+	    DEBUG(("fetch: seek failed\n"));
+	    return (output);
+	}
+	if (fread((POINTER) buffer, 1, keysize, basef) != keysize) {
+	    DEBUG(("fetch: read failed\n"));
+	    return (output);
+	}
+	/* try it */
+	buffer[keysize] = '\0';	/* terminated for DEBUG */
+	(void)mapcase(buffer, buffer, keysize);
+	DEBUG(("fetch: buffer (%s) looking for (%s) size = %d\n",
+	       buffer, key.dptr, keysize));
+	if (memcmp((POINTER) key.dptr, (POINTER) buffer, cmplen) == 0 &&
+	    (*sepp == conf.fieldsep || *sepp == '\0')) {
+	    /* we found it */
+	    output.dptr = (char *)&key_ptr;
+	    output.dsize = SOF;
+	    DEBUG(("fetch: successful\n"));
+	    return (output);
+	}
+    }
+
+    /* we didn't find it */
+    DEBUG(("fetch: failed\n"));
+    prevp = &srch;		/* remember where we stopped */
+    return (output);
 }
 
 /*
- - latebase - try to open a base file that wasn't there at the start
+ * - latebase - try to open a base file that wasn't there at the start
  */
-static FILE *
+static FILE    *
 latebase()
 {
-	register FILE *it;
-
-	if (basefname == NULL) {
-		DEBUG(("latebase: name foulup\n"));
-		return(NULL);
-	}
-	it = fopen(basefname, "r");
-	if (it == NULL) {
-		DEBUG(("latebase: still can't open base\n"));
-	} else {
-		DEBUG(("latebase: late open succeeded\n"));
-		free((POINTER)basefname);
-		basefname = NULL;
+    register FILE  *it;
+
+    if (basefname == NULL) {
+	DEBUG(("latebase: name foulup\n"));
+	return (NULL);
+    }
+    it = fopen(basefname, "r");
+    if (it == NULL) {
+	DEBUG(("latebase: still can't open base\n"));
+    } else {
+	DEBUG(("latebase: late open succeeded\n"));
+	free((POINTER) basefname);
+	basefname = NULL;
 #ifdef _IOFBF
-		(void) setvbuf(it, basebuf, _IOFBF, sizeof(basebuf));
+	(void)setvbuf(it, basebuf, _IOFBF, sizeof(basebuf));
 #endif
-	}
-	if (it != NULL)
-		CloseOnExec((int)fileno(it), 1);
-	return(it);
+    }
+    if (it != NULL)
+	CloseOnExec((int)fileno(it), 1);
+    return (it);
 }
 
 /*
- - dbzstore - store() with case mapping built in
+ * - dbzstore - store() with case mapping built in
  */
 int
 dbzstore(key, data)
-datum key;
-datum data;
+    datum           key;
+    datum           data;
 {
-	char buffer[DBZMAXKEY + 1];
-	datum mappedkey;
-	register size_t keysize;
-
-	DEBUG(("dbzstore: (%s)\n", key.dptr));
-
-	/* Key is supposed to be less than DBZMAXKEY */
-	keysize = key.dsize;
-	if (keysize >= DBZMAXKEY) {
-		DEBUG(("dbzstore: key size too big (%d)\n", key.dsize));
-		return(-1);
-	}
-
-	mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
-	buffer[keysize] = '\0';	/* just a debug aid */
-	mappedkey.dsize = keysize;
-
-	return(store(mappedkey, data));
+    char            buffer[DBZMAXKEY + 1];
+    datum           mappedkey;
+    register size_t keysize;
+
+    DEBUG(("dbzstore: (%s)\n", key.dptr));
+
+    /* Key is supposed to be less than DBZMAXKEY */
+    keysize = key.dsize;
+    if (keysize >= DBZMAXKEY) {
+	DEBUG(("dbzstore: key size too big (%d)\n", key.dsize));
+	return (-1);
+    }
+    mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
+    buffer[keysize] = '\0';	/* just a debug aid */
+    mappedkey.dsize = keysize;
+
+    return (store(mappedkey, data));
 }
 
 /*
- - store - add an entry to the database
+ * - store - add an entry to the database
  */
 int				/* 0 success, -1 failure */
 store(key, data)
-datum key;
-datum data;
+    datum           key;
+    datum           data;
 {
-	of_t value;
-
-	if (pagf == NULL) {
-		DEBUG(("store: database not open!\n"));
-		return(-1);
-	} else if (basef == NULL) {	/* basef didn't exist yet */
-		basef = latebase();
-		if (basef == NULL)
-			return(-1);
-	}
-	if (pagronly) {
-		DEBUG(("store: database open read-only\n"));
-		return(-1);
-	}
-	if (data.dsize != SOF) {
-		DEBUG(("store: value size wrong (%d)\n", data.dsize));
-		return(-1);
-	}
-	if (key.dsize >= DBZMAXKEY) {
-		DEBUG(("store: key size too big (%d)\n", key.dsize));
-		return(-1);
-	}
-
-	/* copy the value in to ensure alignment */
-	(void) memcpy((POINTER)&value, (POINTER)data.dptr, SOF);
-	DEBUG(("store: (%s, %ld)\n", key.dptr, (long)value));
-	if (!okayvalue(value)) {
-		DEBUG(("store: reserved bit or overflow in 0x%lx\n", value));
-		return(-1);
-	}
-
-	/* find the place, exploiting previous search if possible */
-	start(&srch, &key, prevp);
-	while (search(&srch) != NOTFOUND)
-		continue;
-
-	prevp = FRESH;
-	conf.used[0]++;
-	DEBUG(("store: used count %ld\n", conf.used[0]));
-	written = 1;
-	return(set(&srch, value));
+    of_t            value;
+
+    if (pagf == NULL) {
+	DEBUG(("store: database not open!\n"));
+	return (-1);
+    } else if (basef == NULL) {	/* basef didn't exist yet */
+	basef = latebase();
+	if (basef == NULL)
+	    return (-1);
+    }
+    if (pagronly) {
+	DEBUG(("store: database open read-only\n"));
+	return (-1);
+    }
+    if (data.dsize != SOF) {
+	DEBUG(("store: value size wrong (%d)\n", data.dsize));
+	return (-1);
+    }
+    if (key.dsize >= DBZMAXKEY) {
+	DEBUG(("store: key size too big (%d)\n", key.dsize));
+	return (-1);
+    }
+    /* copy the value in to ensure alignment */
+    (void)memcpy((POINTER) & value, (POINTER) data.dptr, SOF);
+    DEBUG(("store: (%s, %ld)\n", key.dptr, (long)value));
+    if (!okayvalue(value)) {
+	DEBUG(("store: reserved bit or overflow in 0x%lx\n", value));
+	return (-1);
+    }
+    /* find the place, exploiting previous search if possible */
+    start(&srch, &key, prevp);
+    while (search(&srch) != NOTFOUND)
+	continue;
+
+    prevp = FRESH;
+    conf.used[0]++;
+    DEBUG(("store: used count %ld\n", conf.used[0]));
+    written = 1;
+    return (set(&srch, value));
 }
 
 /*
- - dbzincore - control attempts to keep .pag file in core
+ * - dbzincore - control attempts to keep .pag file in core
  */
 int				/* old setting */
 dbzincore(value)
-int value;
+    int             value;
 {
-	register int old = incore;
+    register int    old = incore;
 
 #ifndef MMAP
-	incore = value;
+    incore = value;
 #endif
-	return(old);
+    return (old);
 }
 
 /*
- - dbzwritethrough - write through the pag file in core
+ * - dbzwritethrough - write through the pag file in core
  */
 int				/* old setting */
 dbzwritethrough(value)
-int value;
+    int             value;
 {
-	register int old = writethrough;
+    register int    old = writethrough;
 
-	writethrough = value;
-	return(old);
+    writethrough = value;
+    return (old);
 }
 
 /*
- - dbztagmask - calculate the correct tagmask for the given base file size
+ * - dbztagmask - calculate the correct tagmask for the given base file size
  */
 long
 dbztagmask(size)
-register long size;
+    register long   size;
 {
-	register long m;
-	register long tagmask;
-	register int i;
+    register long   m;
+    register long   tagmask;
+    register int    i;
 
-	if (size <= 0)
-		return(0L);		/* silly size */
+    if (size <= 0)
+	return (0L);		/* silly size */
 
-	for (m = 1, i = 0; m < size; i++, m <<= 1)
-		continue;
+    for (m = 1, i = 0; m < size; i++, m <<= 1)
+	continue;
 
-	if (m < (1 << TAGSHIFT))
-		return(0L);		/* not worth tagging */
+    if (m < (1 << TAGSHIFT))
+	return (0L);		/* not worth tagging */
 
-	tagmask = (~(unsigned long)0) >> (i + 1);
-	tagmask = tagmask << i;
-	return(tagmask);
+    tagmask = (~(unsigned long)0) >> (i + 1);
+    tagmask = tagmask << i;
+    return (tagmask);
 }
 
 /*
- - getconf - get configuration from .dir file
+ * - getconf - get configuration from .dir file
  */
 static int			/* 0 success, -1 failure */
 getconf(df, pf, cp)
-register FILE *df;		/* NULL means just give me the default */
-register FILE *pf;		/* NULL means don't care about .pag */
-register struct dbzconfig *cp;
+    register FILE  *df;		/* NULL means just give me the default */
+    register FILE  *pf;		/* NULL means don't care about .pag */
+    register struct dbzconfig *cp;
 {
-	register int c;
-	register int i;
-	int err = 0;
-
-	c = (df != NULL) ? getc(df) : EOF;
-	if (c == EOF) {		/* empty file, no configuration known */
-		cp->olddbz = 0;
-		if (df != NULL && pf != NULL && getc(pf) != EOF)
-			cp->olddbz = 1;
-		cp->tsize = DEFSIZE;
-		cp->fieldsep = '\t';
-		for (i = 0; i < NUSEDS; i++)
-			cp->used[i] = 0;
-		cp->valuesize = SOF;
-		mybytemap(cp->bytemap);
-		cp->casemap = DEFCASE;
-		cp->tagenb = TAGENB;
-		cp->tagmask = TAGMASK;
-		cp->tagshift = TAGSHIFT;
-		DEBUG(("getconf: defaults (%ld, %c, (0x%lx/0x%lx<<%d))\n",
-			cp->tsize, cp->casemap, cp->tagenb, 
-			cp->tagmask, cp->tagshift));
-		return(0);
-	}
-	(void) ungetc(c, df);
-
-	/* first line, the vital stuff */
-	if (getc(df) != 'd' || getc(df) != 'b' || getc(df) != 'z')
-		err = -1;
-	if (getno(df, &err) != dbzversion)
-		err = -1;
-	cp->tsize = getno(df, &err);
-	cp->fieldsep = (int)getno(df, &err);
-	while ((c = getc(df)) == ' ')
-		continue;
-	cp->casemap = c;
-	cp->tagenb = getno(df, &err);
-	cp->tagmask = getno(df, &err);
-	cp->tagshift = getno(df, &err);
-	cp->valuesize = getno(df, &err);
-	if (cp->valuesize != SOF) {
-		DEBUG(("getconf: wrong of_t size (%d)\n", cp->valuesize));
-		err = -1;
-		cp->valuesize = SOF;	/* to protect the loops below */
-	}
-	for (i = 0; i < cp->valuesize; i++)
-		cp->bytemap[i] = getno(df, &err);
-	if (getc(df) != '\n')
-		err = -1;
+    register int    c;
+    register int    i;
+    int             err = 0;
+
+    c = (df != NULL) ? getc(df) : EOF;
+    if (c == EOF) {		/* empty file, no configuration known */
+	cp->olddbz = 0;
+	if (df != NULL && pf != NULL && getc(pf) != EOF)
+	    cp->olddbz = 1;
+	cp->tsize = DEFSIZE;
+	cp->fieldsep = '\t';
+	for (i = 0; i < NUSEDS; i++)
+	    cp->used[i] = 0;
+	cp->valuesize = SOF;
+	mybytemap(cp->bytemap);
+	cp->casemap = DEFCASE;
+	cp->tagenb = TAGENB;
+	cp->tagmask = TAGMASK;
+	cp->tagshift = TAGSHIFT;
+	DEBUG(("getconf: defaults (%ld, %c, (0x%lx/0x%lx<<%d))\n",
+	       cp->tsize, cp->casemap, cp->tagenb,
+	       cp->tagmask, cp->tagshift));
+	return (0);
+    }
+    (void)ungetc(c, df);
+
+    /* first line, the vital stuff */
+    if (getc(df) != 'd' || getc(df) != 'b' || getc(df) != 'z')
+	err = -1;
+    if (getno(df, &err) != dbzversion)
+	err = -1;
+    cp->tsize = getno(df, &err);
+    cp->fieldsep = (int)getno(df, &err);
+    while ((c = getc(df)) == ' ')
+	continue;
+    cp->casemap = c;
+    cp->tagenb = getno(df, &err);
+    cp->tagmask = getno(df, &err);
+    cp->tagshift = getno(df, &err);
+    cp->valuesize = getno(df, &err);
+    if (cp->valuesize != SOF) {
+	DEBUG(("getconf: wrong of_t size (%d)\n", cp->valuesize));
+	err = -1;
+	cp->valuesize = SOF;	/* to protect the loops below */
+    }
+    for (i = 0; i < cp->valuesize; i++)
+	cp->bytemap[i] = getno(df, &err);
+    if (getc(df) != '\n')
+	err = -1;
 #ifdef DBZDEBUG
-	DEBUG(("size %ld, sep %d, cmap %c, tags 0x%lx/0x%lx<<%d, ", cp->tsize,
-			cp->fieldsep, cp->casemap, cp->tagenb, cp->tagmask,
-			cp->tagshift));
-	DEBUG(("bytemap (%d)", cp->valuesize));
-	for (i = 0; i < cp->valuesize; i++) {
-		DEBUG((" %d", cp->bytemap[i]));
-	}
-	DEBUG(("\n"));
+    DEBUG(("size %ld, sep %d, cmap %c, tags 0x%lx/0x%lx<<%d, ", cp->tsize,
+	   cp->fieldsep, cp->casemap, cp->tagenb, cp->tagmask,
+	   cp->tagshift));
+    DEBUG(("bytemap (%d)", cp->valuesize));
+    for (i = 0; i < cp->valuesize; i++) {
+	DEBUG((" %d", cp->bytemap[i]));
+    }
+    DEBUG(("\n"));
 #endif
 
-	/* second line, the usages */
-	for (i = 0; i < NUSEDS; i++)
-		cp->used[i] = getno(df, &err);
-	if (getc(df) != '\n')
-		err = -1;
-	DEBUG(("used %ld %ld %ld...\n", cp->used[0], cp->used[1], cp->used[2]));
-
-	if (err < 0) {
-		DEBUG(("getconf error\n"));
-		return(-1);
-	}
-	return(0);
+    /* second line, the usages */
+    for (i = 0; i < NUSEDS; i++)
+	cp->used[i] = getno(df, &err);
+    if (getc(df) != '\n')
+	err = -1;
+    DEBUG(("used %ld %ld %ld...\n", cp->used[0], cp->used[1], cp->used[2]));
+
+    if (err < 0) {
+	DEBUG(("getconf error\n"));
+	return (-1);
+    }
+    return (0);
 }
 
 /*
- - getno - get a long
+ * - getno - get a long
  */
 static long
 getno(f, ep)
-FILE *f;
-int *ep;
+    FILE           *f;
+    int            *ep;
 {
-	register char *p;
-#	define	MAXN	50
-	char getbuf[MAXN];
-	register int c;
-
-	while ((c = getc(f)) == ' ')
-		continue;
-	if (c == EOF || c == '\n') {
-		DEBUG(("getno: missing number\n"));
-		*ep = -1;
-		return(0);
-	}
-	p = getbuf;
-	*p++ = c;
-	while ((c = getc(f)) != EOF && c != '\n' && c != ' ')
-		if (p < &getbuf[MAXN-1])
-			*p++ = c;
-	if (c == EOF) {
-		DEBUG(("getno: EOF\n"));
-		*ep = -1;
-	} else
-		(void) ungetc(c, f);
-	*p = '\0';
-
-	if (strspn(getbuf, "-1234567890") != strlen(getbuf)) {
-		DEBUG(("getno: `%s' non-numeric\n", getbuf));
-		*ep = -1;
-	}
-	return(atol(getbuf));
+    register char  *p;
+#define	MAXN	50
+    char            getbuf[MAXN];
+    register int    c;
+
+    while ((c = getc(f)) == ' ')
+	continue;
+    if (c == EOF || c == '\n') {
+	DEBUG(("getno: missing number\n"));
+	*ep = -1;
+	return (0);
+    }
+    p = getbuf;
+    *p++ = c;
+    while ((c = getc(f)) != EOF && c != '\n' && c != ' ')
+	if (p < &getbuf[MAXN - 1])
+	    *p++ = c;
+    if (c == EOF) {
+	DEBUG(("getno: EOF\n"));
+	*ep = -1;
+    } else
+	(void)ungetc(c, f);
+    *p = '\0';
+
+    if (strspn(getbuf, "-1234567890") != strlen(getbuf)) {
+	DEBUG(("getno: `%s' non-numeric\n", getbuf));
+	*ep = -1;
+    }
+    return (atol(getbuf));
 }
 
 /*
- - putconf - write configuration to .dir file
+ * - putconf - write configuration to .dir file
  */
 static int			/* 0 success, -1 failure */
 putconf(f, cp)
-register FILE *f;
-register struct dbzconfig *cp;
+    register FILE  *f;
+    register struct dbzconfig *cp;
 {
-	register int i;
-	register int ret = 0;
-
-	if (fseek(f, (of_t)0, SEEK_SET) != 0) {
-		DEBUG(("fseek failure in putconf\n"));
-		ret = -1;
-	}
-	(void) fprintf(f, "dbz %d %ld %d %c %ld %ld %d %d", dbzversion, cp->tsize,
-				cp->fieldsep, cp->casemap, cp->tagenb,
-				cp->tagmask, cp->tagshift, cp->valuesize);
-	for (i = 0; i < cp->valuesize; i++)
-		(void) fprintf(f, " %d", cp->bytemap[i]);
-	(void) fprintf(f, "\n");
-	for (i = 0; i < NUSEDS; i++)
-		(void) fprintf(f, "%ld%c", cp->used[i], (i < NUSEDS-1) ? ' ' : '\n');
-
-	(void) fflush(f);
-	if (ferror(f))
-		ret = -1;
-
-	DEBUG(("putconf status %d\n", ret));
-	return(ret);
+    register int    i;
+    register int    ret = 0;
+
+    if (fseek(f, (of_t) 0, SEEK_SET) != 0) {
+	DEBUG(("fseek failure in putconf\n"));
+	ret = -1;
+    }
+    (void)fprintf(f, "dbz %d %ld %d %c %ld %ld %d %d", dbzversion, cp->tsize,
+		  cp->fieldsep, cp->casemap, cp->tagenb,
+		  cp->tagmask, cp->tagshift, cp->valuesize);
+    for (i = 0; i < cp->valuesize; i++)
+	(void)fprintf(f, " %d", cp->bytemap[i]);
+    (void)fprintf(f, "\n");
+    for (i = 0; i < NUSEDS; i++)
+	(void)fprintf(f, "%ld%c", cp->used[i], (i < NUSEDS - 1) ? ' ' : '\n');
+
+    (void)fflush(f);
+    if (ferror(f))
+	ret = -1;
+
+    DEBUG(("putconf status %d\n", ret));
+    return (ret);
 }
 
 /*
- - getcore - try to set up an in-core copy of .pag file
+ * - getcore - try to set up an in-core copy of .pag file
  */
-static of_t *			/* pointer to copy, or NULL */
+static of_t    *		/* pointer to copy, or NULL */
 getcore(f)
-FILE *f;
+    FILE           *f;
 {
-	register of_t *p;
-	register size_t i;
-	register size_t nread;
-	register char *it;
+    register of_t  *p;
+    register size_t i;
+    register size_t nread;
+    register char  *it;
 #ifdef MMAP
-	struct stat st;
-
-	if (fstat(fileno(f), &st) == -1) {
-		DEBUG(("getcore: fstat failed\n"));
-		return(NULL);
-	}
-	if (((size_t)conf.tsize * SOF) > st.st_size) {
-		/* file too small; extend it */
-		if (ftruncate((int)fileno(f), conf.tsize * SOF) == -1) {
-			DEBUG(("getcore: ftruncate failed\n"));
-			return(NULL);
-		}
-	}
-	it = mmap((caddr_t)0, (size_t)conf.tsize * SOF, 
-		pagronly ? PROT_READ : PROT_WRITE | PROT_READ, MAP__ARG,
-		(int)fileno(f), (off_t)0);
-	if (it == (char *)-1) {
-		DEBUG(("getcore: mmap failed\n"));
-		return(NULL);
-	}
+    struct stat     st;
+
+    if (fstat(fileno(f), &st) == -1) {
+	DEBUG(("getcore: fstat failed\n"));
+	return (NULL);
+    }
+    if (((size_t) conf.tsize * SOF) > st.st_size) {
+	/* file too small; extend it */
+	if (ftruncate((int)fileno(f), conf.tsize * SOF) == -1) {
+	    DEBUG(("getcore: ftruncate failed\n"));
+	    return (NULL);
+	}
+    }
+    it = mmap((caddr_t) 0, (size_t) conf.tsize * SOF,
+	      pagronly ? PROT_READ : PROT_WRITE | PROT_READ, MAP__ARG,
+	      (int)fileno(f), (off_t) 0);
+    if (it == (char *)-1) {
+	DEBUG(("getcore: mmap failed\n"));
+	return (NULL);
+    }
 #ifdef MC_ADVISE
-	/* not present in all versions of mmap() */
-	madvise(it, (size_t)conf.tsize * SOF, MADV_RANDOM);
+    /* not present in all versions of mmap() */
+    madvise(it, (size_t) conf.tsize * SOF, MADV_RANDOM);
 #endif
 #else
-	it = malloc((size_t)conf.tsize * SOF);
-	if (it == NULL) {
-		DEBUG(("getcore: malloc failed\n"));
-		return(NULL);
-	}
-
-	nread = fread((POINTER)it, SOF, (size_t)conf.tsize, f);
-	if (ferror(f)) {
-		DEBUG(("getcore: read failed\n"));
-		free((POINTER)it);
-		return(NULL);
-	}
-
- 	/* NOSTRICT *//* Possible pointer alignment problem */
-	p = (of_t *)it + nread;
-	i = (size_t)conf.tsize - nread;
-	while (i-- > 0)
-		*p++ = VACANT;
+    it = malloc((size_t) conf.tsize * SOF);
+    if (it == NULL) {
+	DEBUG(("getcore: malloc failed\n"));
+	return (NULL);
+    }
+    nread = fread((POINTER) it, SOF, (size_t) conf.tsize, f);
+    if (ferror(f)) {
+	DEBUG(("getcore: read failed\n"));
+	free((POINTER) it);
+	return (NULL);
+    }
+    /* NOSTRICT *//* Possible pointer alignment problem */
+    p = (of_t *) it + nread;
+    i = (size_t) conf.tsize - nread;
+    while (i-- > 0)
+	*p++ = VACANT;
 #endif
- 	/* NOSTRICT *//* Possible pointer alignment problem */
-	return((of_t *)it);
+    /* NOSTRICT *//* Possible pointer alignment problem */
+    return ((of_t *) it);
 }
 
 #ifndef MMAP
 /*
- - putcore - try to rewrite an in-core table
+ * - putcore - try to rewrite an in-core table
  */
 static int			/* 0 okay, -1 fail */
 putcore(tab, f)
-of_t *tab;
-FILE *f;
+    of_t           *tab;
+    FILE           *f;
 {
-	if (fseek(f, (of_t)0, SEEK_SET) != 0) {
-		DEBUG(("fseek failure in putcore\n"));
-		return(-1);
-	}
-	(void) fwrite((POINTER)tab, SOF, (size_t)conf.tsize, f);
-	(void) fflush(f);
-	return((ferror(f)) ? -1 : 0);
+    if (fseek(f, (of_t) 0, SEEK_SET) != 0) {
+	DEBUG(("fseek failure in putcore\n"));
+	return (-1);
+    }
+    (void)fwrite((POINTER) tab, SOF, (size_t) conf.tsize, f);
+    (void)fflush(f);
+    return ((ferror(f)) ? -1 : 0);
 }
 #endif
 
 /*
- - start - set up to start or restart a search
+ * - start - set up to start or restart a search
  */
 static void
 start(sp, kp, osp)
-register struct searcher *sp;
-register datum *kp;
-register struct searcher *osp;		/* may be FRESH, i.e. NULL */
+    register struct searcher *sp;
+    register datum *kp;
+    register struct searcher *osp;	/* may be FRESH, i.e. NULL */
 {
-	register long h;
-
-	h = hash(kp->dptr, kp->dsize);
-	if (osp != FRESH && osp->hash == h) {
-		if (sp != osp)
-			*sp = *osp;
-		DEBUG(("search restarted\n"));
-	} else {
-		sp->hash = h;
-		sp->tag = MKTAG(h / conf.tsize);
-		DEBUG(("tag 0x%lx\n", sp->tag));
-		sp->place = h % conf.tsize;
-		sp->tabno = 0;
-		sp->run = (conf.olddbz) ? conf.tsize : MAXRUN;
-		sp->aborted = 0;
-	}
-	sp->seen = 0;
+    register long   h;
+
+    h = hash(kp->dptr, kp->dsize);
+    if (osp != FRESH && osp->hash == h) {
+	if (sp != osp)
+	    *sp = *osp;
+	DEBUG(("search restarted\n"));
+    } else {
+	sp->hash = h;
+	sp->tag = MKTAG(h / conf.tsize);
+	DEBUG(("tag 0x%lx\n", sp->tag));
+	sp->place = h % conf.tsize;
+	sp->tabno = 0;
+	sp->run = (conf.olddbz) ? conf.tsize : MAXRUN;
+	sp->aborted = 0;
+    }
+    sp->seen = 0;
 }
 
 /*
- - search - conduct part of a search
+ * - search - conduct part of a search
  */
-static of_t			/* NOTFOUND if we hit VACANT or error */
+static          of_t		/* NOTFOUND if we hit VACANT or error */
 search(sp)
-register struct searcher *sp;
+    register struct searcher *sp;
 {
-	register of_t dest;
-	register of_t value;
-	of_t val;		/* buffer for value (can't fread register) */
-	register of_t place;
-
-	if (sp->aborted)
-		return(NOTFOUND);
-
-	for (;;) {
-		/* determine location to be examined */
-		place = sp->place;
-		if (sp->seen) {
-			/* go to next location */
-			if (--sp->run <= 0) {
-				sp->tabno++;
-				sp->run = MAXRUN;
-			}
-			place = (place+1)%conf.tsize + sp->tabno*conf.tsize;
-			sp->place = place;
-		} else
-			sp->seen = 1;	/* now looking at current location */
-		DEBUG(("search @ %ld\n", place));
-
-		/* get the tagged value */
-		if (corepag != NULL && place < conf.tsize) {
-			DEBUG(("search: in core\n"));
-			value = MAPIN(corepag[place]);
-		} else {
-			/* seek, if necessary */
-			dest = place * SOF;
-			if (pagpos != dest) {
-				if (fseek(pagf, dest, SEEK_SET) != 0) {
-					DEBUG(("search: seek failed\n"));
-					pagpos = -1;
-					sp->aborted = 1;
-					return(NOTFOUND);
-				}
-				pagpos = dest;
-			}
-
-			/* read it */
-			if (fread((POINTER)&val, sizeof(val), 1, pagf) == 1)
-				value = MAPIN(val);
-			else if (ferror(pagf)) {
-				DEBUG(("search: read failed\n"));
-				pagpos = -1;
-				sp->aborted = 1;
-				return(NOTFOUND);
-			} else
-				value = VACANT;
-
-			/* and finish up */
-			pagpos += sizeof(val);
-		}
+    register of_t   dest;
+    register of_t   value;
+    of_t            val;	/* buffer for value (can't fread register) */
+    register of_t   place;
+
+    if (sp->aborted)
+	return (NOTFOUND);
+
+    for (;;) {
+	/* determine location to be examined */
+	place = sp->place;
+	if (sp->seen) {
+	    /* go to next location */
+	    if (--sp->run <= 0) {
+		sp->tabno++;
+		sp->run = MAXRUN;
+	    }
+	    place = (place + 1) % conf.tsize + sp->tabno * conf.tsize;
+	    sp->place = place;
+	} else
+	    sp->seen = 1;	/* now looking at current location */
+	DEBUG(("search @ %ld\n", place));
 
-		/* vacant slot is always cause to return */
-		if (value == VACANT) {
-			DEBUG(("search: empty slot\n"));
-			return(NOTFOUND);
-		};
-
-		/* check the tag */
-		value = UNBIAS(value);
-		DEBUG(("got 0x%lx\n", value));
-		if (!HASTAG(value)) {
-			DEBUG(("tagless\n"));
-			return(value);
-		} else if (TAG(value) == sp->tag) {
-			DEBUG(("match\n"));
-			return(NOTAG(value));
-		} else {
-			DEBUG(("mismatch 0x%lx\n", TAG(value)));
+	/* get the tagged value */
+	if (corepag != NULL && place < conf.tsize) {
+	    DEBUG(("search: in core\n"));
+	    value = MAPIN(corepag[place]);
+	} else {
+	    /* seek, if necessary */
+	    dest = place * SOF;
+	    if (pagpos != dest) {
+		if (fseek(pagf, dest, SEEK_SET) != 0) {
+		    DEBUG(("search: seek failed\n"));
+		    pagpos = -1;
+		    sp->aborted = 1;
+		    return (NOTFOUND);
 		}
+		pagpos = dest;
+	    }
+	    /* read it */
+	    if (fread((POINTER) & val, sizeof(val), 1, pagf) == 1)
+		value = MAPIN(val);
+	    else if (ferror(pagf)) {
+		DEBUG(("search: read failed\n"));
+		pagpos = -1;
+		sp->aborted = 1;
+		return (NOTFOUND);
+	    } else
+		value = VACANT;
+
+	    /* and finish up */
+	    pagpos += sizeof(val);
+	}
+
+	/* vacant slot is always cause to return */
+	if (value == VACANT) {
+	    DEBUG(("search: empty slot\n"));
+	    return (NOTFOUND);
+	};
+
+	/* check the tag */
+	value = UNBIAS(value);
+	DEBUG(("got 0x%lx\n", value));
+	if (!HASTAG(value)) {
+	    DEBUG(("tagless\n"));
+	    return (value);
+	} else if (TAG(value) == sp->tag) {
+	    DEBUG(("match\n"));
+	    return (NOTAG(value));
+	} else {
+	    DEBUG(("mismatch 0x%lx\n", TAG(value)));
 	}
-	/* NOTREACHED */
+    }
+    /* NOTREACHED */
 }
 
 /*
- - okayvalue - check that a value can be stored
+ * - okayvalue - check that a value can be stored
  */
 static int			/* predicate */
 okayvalue(value)
-of_t value;
+    of_t            value;
 {
-	if (HASTAG(value))
-		return(0);
+    if (HASTAG(value))
+	return (0);
 #ifdef OVERFLOW
-	if (value == LONG_MAX)	/* BIAS() and UNBIAS() will overflow */
-		return(0);
+    if (value == LONG_MAX)	/* BIAS() and UNBIAS() will overflow */
+	return (0);
 #endif
-	return(1);
+    return (1);
 }
 
 /*
- - set - store a value into a location previously found by search
+ * - set - store a value into a location previously found by search
  */
 static int			/* 0 success, -1 failure */
 set(sp, value)
-register struct searcher *sp;
-of_t value;
+    register struct searcher *sp;
+    of_t            value;
 {
-	register of_t place = sp->place;
-	register of_t v = value;
+    register of_t   place = sp->place;
+    register of_t   v = value;
 
-	if (sp->aborted)
-		return(-1);
+    if (sp->aborted)
+	return (-1);
 
-	if (CANTAG(v) && !conf.olddbz) {
-		v |= sp->tag | taghere;
-		if (v != UNBIAS(VACANT))	/* BIAS(v) won't look VACANT */
+    if (CANTAG(v) && !conf.olddbz) {
+	v |= sp->tag | taghere;
+	if (v != UNBIAS(VACANT))/* BIAS(v) won't look VACANT */
 #ifdef OVERFLOW
-			if (v != LONG_MAX)	/* and it won't overflow */
+	    if (v != LONG_MAX)	/* and it won't overflow */
 #endif
-			value = v;
-	}
-	DEBUG(("tagged value is 0x%lx\n", value));
-	value = BIAS(value);
-	value = MAPOUT(value);
-
-	/* If we have the index file in memory, use it */
-	if (corepag != NULL && place < conf.tsize) {
-		corepag[place] = value;
-		DEBUG(("set: incore\n"));
+		value = v;
+    }
+    DEBUG(("tagged value is 0x%lx\n", value));
+    value = BIAS(value);
+    value = MAPOUT(value);
+
+    /* If we have the index file in memory, use it */
+    if (corepag != NULL && place < conf.tsize) {
+	corepag[place] = value;
+	DEBUG(("set: incore\n"));
 #ifdef MMAP
-		return(0);
+	return (0);
 #else
-		if (!writethrough)
-			return(0);
+	if (!writethrough)
+	    return (0);
 #endif
-	}
-
-	/* seek to spot */
-	pagpos = -1;		/* invalidate position memory */
-	if (fseek(pagf, (of_t)(place * SOF), SEEK_SET) != 0) {
-		DEBUG(("set: seek failed\n"));
-		sp->aborted = 1;
-		return(-1);
-	}
-
-	/* write in data */
-	if (fwrite((POINTER)&value, SOF, 1, pagf) != 1) {
-		DEBUG(("set: write failed\n"));
-		sp->aborted = 1;
-		return(-1);
-	}
-	/* fflush improves robustness, and buffer re-use is rare anyway */
-	if (fflush(pagf) == EOF) {
-		DEBUG(("set: fflush failed\n"));
-		sp->aborted = 1;
-		return(-1);
-	}
-
-	DEBUG(("set: succeeded\n"));
-	return(0);
+    }
+    /* seek to spot */
+    pagpos = -1;		/* invalidate position memory */
+    if (fseek(pagf, (of_t) (place * SOF), SEEK_SET) != 0) {
+	DEBUG(("set: seek failed\n"));
+	sp->aborted = 1;
+	return (-1);
+    }
+    /* write in data */
+    if (fwrite((POINTER) & value, SOF, 1, pagf) != 1) {
+	DEBUG(("set: write failed\n"));
+	sp->aborted = 1;
+	return (-1);
+    }
+    /* fflush improves robustness, and buffer re-use is rare anyway */
+    if (fflush(pagf) == EOF) {
+	DEBUG(("set: fflush failed\n"));
+	sp->aborted = 1;
+	return (-1);
+    }
+    DEBUG(("set: succeeded\n"));
+    return (0);
 }
 
 /*
- - mybytemap - determine this machine's byte map
- *
- * A byte map is an array of ints, sizeof(of_t) of them.  The 0th int
- * is the byte number of the high-order byte in my of_t, and so forth.
+ * - mybytemap - determine this machine's byte map
+ * 
+ * A byte map is an array of ints, sizeof(of_t) of them.  The 0th int is the
+ * byte number of the high-order byte in my of_t, and so forth.
  */
 static void
 mybytemap(map)
-int map[];			/* -> int[SOF] */
+    int             map[];	/* -> int[SOF] */
 {
-	union {
-		of_t o;
-		char c[SOF];
-	} u;
-	register int *mp = &map[SOF];
-	register int ntodo;
-	register int i;
-
-	u.o = 1;
-	for (ntodo = (int)SOF; ntodo > 0; ntodo--) {
-		for (i = 0; i < SOF; i++)
-			/* SUPPRESS 112 *//* Retrieving char where long is stored */
-			if (u.c[i] != 0)
-				break;
-		if (i == SOF) {
-			/* trouble -- set it to *something* consistent */
-			DEBUG(("mybytemap: nonexistent byte %d!!!\n", ntodo));
-			for (i = 0; i < SOF; i++)
-				map[i] = i;
-			return;
-		}
-		DEBUG(("mybytemap: byte %d\n", i));
-		*--mp = i;
-		/* SUPPRESS 112 *//* Retrieving char where long is stored */
-		while (u.c[i] != 0)
-			u.o <<= 1;
-	}
+    union {
+	of_t            o;
+	char            c[SOF];
+    }               u;
+    register int   *mp = &map[SOF];
+    register int    ntodo;
+    register int    i;
+
+    u.o = 1;
+    for (ntodo = (int)SOF; ntodo > 0; ntodo--) {
+	for (i = 0; i < SOF; i++)
+	    /* SUPPRESS 112 *//* Retrieving char where long is stored */
+	    if (u.c[i] != 0)
+		break;
+	if (i == SOF) {
+	    /* trouble -- set it to *something* consistent */
+	    DEBUG(("mybytemap: nonexistent byte %d!!!\n", ntodo));
+	    for (i = 0; i < SOF; i++)
+		map[i] = i;
+	    return;
+	}
+	DEBUG(("mybytemap: byte %d\n", i));
+	*--mp = i;
+	/* SUPPRESS 112 *//* Retrieving char where long is stored */
+	while (u.c[i] != 0)
+	    u.o <<= 1;
+    }
 }
 
 /*
- - bytemap - transform an of_t from byte ordering map1 to map2
+ * - bytemap - transform an of_t from byte ordering map1 to map2
  */
-static of_t			/* transformed result */
+static          of_t		/* transformed result */
 bytemap(ino, map1, map2)
-of_t ino;
-int *map1;
-int *map2;
+    of_t            ino;
+    int            *map1;
+    int            *map2;
 {
-	union oc {
-		of_t o;
-		char c[SOF];
-	};
-	union oc in;
-	union oc out;
-	register int i;
-
-	in.o = ino;
-	for (i = 0; i < SOF; i++)
-		out.c[map2[i]] = in.c[map1[i]];
-	return(out.o);
+    union oc {
+	of_t            o;
+	char            c[SOF];
+    };
+    union oc        in;
+    union oc        out;
+    register int    i;
+
+    in.o = ino;
+    for (i = 0; i < SOF; i++)
+	out.c[map2[i]] = in.c[map1[i]];
+    return (out.o);
 }
 
 /*
- * This is a simplified version of the pathalias hashing function.
- * Thanks to Steve Belovin and Peter Honeyman
- *
- * hash a string into a long int.  31 bit crc (from andrew appel).
- * the crc table is computed at run time by crcinit() -- we could
- * precompute, but it takes 1 clock tick on a 750.
- *
- * This fast table calculation works only if POLY is a prime polynomial
- * in the field of integers modulo 2.  Since the coefficients of a
- * 32-bit polynomial won't fit in a 32-bit word, the high-order bit is
- * implicit.  IT MUST ALSO BE THE CASE that the coefficients of orders
- * 31 down to 25 are zero.  Happily, we have candidates, from
- * E. J.  Watson, "Primitive Polynomials (Mod 2)", Math. Comp. 16 (1962):
- *	x^32 + x^7 + x^5 + x^3 + x^2 + x^1 + x^0
- *	x^31 + x^3 + x^0
- *
- * We reverse the bits to get:
- *	111101010000000000000000000000001 but drop the last 1
- *         f   5   0   0   0   0   0   0
- *	010010000000000000000000000000001 ditto, for 31-bit crc
- *	   4   8   0   0   0   0   0   0
+ * This is a simplified version of the pathalias hashing function. Thanks to
+ * Steve Belovin and Peter Honeyman
+ * 
+ * hash a string into a long int.  31 bit crc (from andrew appel). the crc table
+ * is computed at run time by crcinit() -- we could precompute, but it takes
+ * 1 clock tick on a 750.
+ * 
+ * This fast table calculation works only if POLY is a prime polynomial in the
+ * field of integers modulo 2.  Since the coefficients of a 32-bit polynomial
+ * won't fit in a 32-bit word, the high-order bit is implicit.  IT MUST ALSO
+ * BE THE CASE that the coefficients of orders 31 down to 25 are zero.
+ * Happily, we have candidates, from E. J.  Watson, "Primitive Polynomials
+ * (Mod 2)", Math. Comp. 16 (1962): x^32 + x^7 + x^5 + x^3 + x^2 + x^1 + x^0
+ * x^31 + x^3 + x^0
+ * 
+ * We reverse the bits to get: 111101010000000000000000000000001 but drop the
+ * last 1 f   5   0   0   0   0   0   0 010010000000000000000000000000001
+ * ditto, for 31-bit crc 4   8   0   0   0   0   0   0
  */
 
 #define POLY 0x48000000L	/* 31-bit polynomial (avoids sign problems) */
 
-static long CrcTable[128];
+static long     CrcTable[128];
 
 /*
- - crcinit - initialize tables for hash function
+ * - crcinit - initialize tables for hash function
  */
 static void
 crcinit()
 {
-	register int i, j;
-	register long sum;
-
-	for (i = 0; i < 128; ++i) {
-		sum = 0L;
-		for (j = 7 - 1; j >= 0; --j)
-			if (i & (1 << j))
-				sum ^= POLY >> j;
-		CrcTable[i] = sum;
-	}
-	DEBUG(("crcinit: done\n"));
+    register int    i, j;
+    register long   sum;
+
+    for (i = 0; i < 128; ++i) {
+	sum = 0L;
+	for (j = 7 - 1; j >= 0; --j)
+	    if (i & (1 << j))
+		sum ^= POLY >> j;
+	CrcTable[i] = sum;
+    }
+    DEBUG(("crcinit: done\n"));
 }
 
 /*
- - hash - Honeyman's nice hashing function
+ * - hash - Honeyman's nice hashing function
  */
 static long
 hash(name, size)
-register char *name;
-register int size;
+    register char  *name;
+    register int    size;
 {
-	register long sum = 0L;
+    register long   sum = 0L;
 
-	while (size--) {
-		sum = (sum >> 7) ^ CrcTable[(sum ^ (*name++)) & 0x7f];
-	}
-	DEBUG(("hash: returns (%ld)\n", sum));
-	return(sum);
+    while (size--) {
+	sum = (sum >> 7) ^ CrcTable[(sum ^ (*name++)) & 0x7f];
+    }
+    DEBUG(("hash: returns (%ld)\n", sum));
+    return (sum);
 }
 
 /*
  * case-mapping stuff
- *
+ * 
  * Borrowed from C News, by permission of the authors.  Somewhat modified.
- *
- * We exploit the fact that we are dealing only with headers here, and
- * headers are limited to the ASCII characters by RFC822.  It is barely
- * possible that we might be dealing with a translation into another
- * character set, but in particular it's very unlikely for a header
- * character to be outside -128..255.
- *
- * Life would be a whole lot simpler if tolower() could safely and portably
- * be applied to any char.
+ * 
+ * We exploit the fact that we are dealing only with headers here, and headers
+ * are limited to the ASCII characters by RFC822.  It is barely possible that
+ * we might be dealing with a translation into another character set, but in
+ * particular it's very unlikely for a header character to be outside
+ * -128..255.
+ * 
+ * Life would be a whole lot simpler if tolower() could safely and portably be
+ * applied to any char.
  */
 
 #define	OFFSET	128		/* avoid trouble with negative chars */
@@ -1760,159 +1727,159 @@ register int size;
 	(TOLOW((a)[0]) == TOLOW((b)[0]) && casencmp(a, b, n) == 0)
 
 #define	MAPSIZE	(256+OFFSET)
-static char cmap[MAPSIZE];	/* relies on init to '\0' */
-static int mprimed = 0;		/* has cmap been set up? */
+static char     cmap[MAPSIZE];	/* relies on init to '\0' */
+static int      mprimed = 0;	/* has cmap been set up? */
 
 /*
- - mapprime - set up case-mapping stuff
+ * - mapprime - set up case-mapping stuff
  */
 static void
 mapprime()
 {
-	register char *lp;
-	register char *up;
-	register int c;
-	register int i;
-	static char lower[] = "abcdefghijklmnopqrstuvwxyz";
-	static char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-	for (lp = lower, up = upper; *lp != '\0'; lp++, up++) {
-		c = *lp;
-		cmap[c+OFFSET] = c;
-		cmap[*up+OFFSET] = c;
-	}
-	for (i = 0; i < MAPSIZE; i++)
-		if (cmap[i] == '\0')
-			cmap[i] = (char)(i-OFFSET);
-	mprimed = 1;
+    register char  *lp;
+    register char  *up;
+    register int    c;
+    register int    i;
+    static char     lower[] = "abcdefghijklmnopqrstuvwxyz";
+    static char     upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    for (lp = lower, up = upper; *lp != '\0'; lp++, up++) {
+	c = *lp;
+	cmap[c + OFFSET] = c;
+	cmap[*up + OFFSET] = c;
+    }
+    for (i = 0; i < MAPSIZE; i++)
+	if (cmap[i] == '\0')
+	    cmap[i] = (char)(i - OFFSET);
+    mprimed = 1;
 }
 
 /*
- - casencmp - case-independent strncmp
+ * - casencmp - case-independent strncmp
  */
 static int			/* < == > 0 */
 casencmp(s1, s2, len)
-char *s1;
-char *s2;
-int len;
+    char           *s1;
+    char           *s2;
+    int             len;
 {
-	register char *p1;
-	register char *p2;
-	register int n;
-
-	if (!mprimed)
-		mapprime();
-
-	p1 = s1;
-	p2 = s2;
-	n = len;
-	while (--n >= 0 && *p1 != '\0' && TOLOW(*p1) == TOLOW(*p2)) {
-		p1++;
-		p2++;
-	}
-	if (n < 0)
-		return(0);
-
-	/*
-	 * The following case analysis is necessary so that characters
-	 * which look negative collate low against normal characters but
-	 * high against the end-of-string NUL.
-	 */
-	if (*p1 == '\0' && *p2 == '\0')
-		return(0);
-	else if (*p1 == '\0')
-		return(-1);
-	else if (*p2 == '\0')
-		return(1);
-	else
-		return(TOLOW(*p1) - TOLOW(*p2));
+    register char  *p1;
+    register char  *p2;
+    register int    n;
+
+    if (!mprimed)
+	mapprime();
+
+    p1 = s1;
+    p2 = s2;
+    n = len;
+    while (--n >= 0 && *p1 != '\0' && TOLOW(*p1) == TOLOW(*p2)) {
+	p1++;
+	p2++;
+    }
+    if (n < 0)
+	return (0);
+
+    /*
+     * The following case analysis is necessary so that characters which look
+     * negative collate low against normal characters but high against the
+     * end-of-string NUL.
+     */
+    if (*p1 == '\0' && *p2 == '\0')
+	return (0);
+    else if (*p1 == '\0')
+	return (-1);
+    else if (*p2 == '\0')
+	return (1);
+    else
+	return (TOLOW(*p1) - TOLOW(*p2));
 }
 
 /*
- - mapcase - do case-mapped copy
+ * - mapcase - do case-mapped copy
  */
-static char *			/* returns src or dst */
+static char    *		/* returns src or dst */
 mapcase(dst, src, siz)
-char *dst;			/* destination, used only if mapping needed */
-char *src;			/* source; src == dst is legal */
-size_t siz;
+    char           *dst;	/* destination, used only if mapping needed */
+    char           *src;	/* source; src == dst is legal */
+    size_t          siz;
 {
-	register char *s;
-	register char *d;
-	register char *c;	/* case break */
-	register char *e;	/* end of source */
+    register char  *s;
+    register char  *d;
+    register char  *c;		/* case break */
+    register char  *e;		/* end of source */
 
 
-	c = cipoint(src, siz);
-	if (c == NULL)
-		return(src);
+    c = cipoint(src, siz);
+    if (c == NULL)
+	return (src);
 
-	if (!mprimed)
-		mapprime();
-	s = src;
-	e = s + siz;
-	d = dst;
+    if (!mprimed)
+	mapprime();
+    s = src;
+    e = s + siz;
+    d = dst;
 
-	while (s < c)
-		*d++ = *s++;
-	while (s < e)
-		*d++ = TOLOW(*s++);
+    while (s < c)
+	*d++ = *s++;
+    while (s < e)
+	*d++ = TOLOW(*s++);
 
-	return(dst);
+    return (dst);
 }
 
 /*
- - cipoint - where in this message-ID does it become case-insensitive?
- *
+ * - cipoint - where in this message-ID does it become case-insensitive?
+ * 
  * The RFC822 code is not quite complete.  Absolute, total, full RFC822
- * compliance requires a horrible parsing job, because of the arcane
- * quoting conventions -- abc"def"ghi is not equivalent to abc"DEF"ghi,
- * for example.  There are three or four things that might occur in the
- * domain part of a message-id that are case-sensitive.  They don't seem
- * to ever occur in real news, thank Cthulhu.  (What?  You were expecting
- * a merciful and forgiving deity to be invoked in connection with RFC822?
- * Forget it; none of them would come near it.)
+ * compliance requires a horrible parsing job, because of the arcane quoting
+ * conventions -- abc"def"ghi is not equivalent to abc"DEF"ghi, for example.
+ * There are three or four things that might occur in the domain part of a
+ * message-id that are case-sensitive.  They don't seem to ever occur in real
+ * news, thank Cthulhu.  (What?  You were expecting a merciful and forgiving
+ * deity to be invoked in connection with RFC822? Forget it; none of them
+ * would come near it.)
  */
-static char *			/* pointer into s, or NULL for "nowhere" */
+static char    *		/* pointer into s, or NULL for "nowhere" */
 cipoint(s, siz)
-char *s;
-size_t siz;
+    char           *s;
+    size_t          siz;
 {
-	register char *p;
-	static char post[] = "postmaster";
-	static int plen = sizeof(post)-1;
-
-	switch (conf.casemap) {
-	case '0':		/* unmapped, sensible */
-		return(NULL);
-	case 'C':		/* C News, RFC 822 conformant (approx.) */
-		p = memchr((POINTER)s, '@', siz);
-		if (p == NULL)			/* no local/domain split */
-			return(NULL);		/* assume all local */
-		if (p - (s+1) == plen && CISTREQN(s+1, post, plen)) {
-			/* crazy -- "postmaster" is case-insensitive */
-			return(s);
-		}
-		return(p);
-	case '=':		/* 2.11, neither sensible nor conformant */
-		return(s);	/* all case-insensitive */
-	}
-
-	DEBUG(("cipoint: unknown case mapping `%c'\n", conf.casemap));
-	return(NULL);		/* just leave it alone */
+    register char  *p;
+    static char     post[] = "postmaster";
+    static int      plen = sizeof(post) - 1;
+
+    switch (conf.casemap) {
+    case '0':			/* unmapped, sensible */
+	return (NULL);
+    case 'C':			/* C News, RFC 822 conformant (approx.) */
+	p = memchr((POINTER) s, '@', siz);
+	if (p == NULL)		/* no local/domain split */
+	    return (NULL);	/* assume all local */
+	if (p - (s + 1) == plen && CISTREQN(s + 1, post, plen)) {
+	    /* crazy -- "postmaster" is case-insensitive */
+	    return (s);
+	}
+	return (p);
+    case '=':			/* 2.11, neither sensible nor conformant */
+	return (s);		/* all case-insensitive */
+    }
+
+    DEBUG(("cipoint: unknown case mapping `%c'\n", conf.casemap));
+    return (NULL);		/* just leave it alone */
 }
 
 /*
- - dbzdebug - control dbz debugging at run time
+ * - dbzdebug - control dbz debugging at run time
  */
 #ifdef DBZDEBUG
 int				/* old value */
 dbzdebug(value)
-int value;
+    int             value;
 {
-	register int old = debug;
+    register int    old = debug;
 
-	debug = value;
-	return(old);
+    debug = value;
+    return (old);
 }
 #endif