mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.37 and 1.49.2.12

version 1.37, 2011/12/20 21:41:11

version 1.49.2.12, 2014/03/19 22:09:29

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 19

#include "config.h"

#endif

#include <sys/param.h>

#include <sys/types.h>

#include <assert.h>

#include <ctype.h>

#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <getopt.h>

#include <limits.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#if defined(__linux__)

#if defined(__APPLE__)

# include <libkern/OSByteOrder.h>

#elif defined(__linux__)

# include <endian.h>

#elif defined(__sun)

# include <sys/byteorder.h>

# include <sys/stat.h>

#else

# include <sys/endian.h>

#endif

#if defined(__linux__) || defined(__sun)

# include <db_185.h>

#elif defined(__APPLE__)

# include <libkern/OSByteOrder.h>

# include <db.h>

#else

# include <db.h>

#endif

Line 54

Line 63

#define MANDOC_SRC 0x1

#define MANDOC_FORM 0x2

/* Access to the mandoc database on disk. */

struct mdb {

char idxn[PATH_MAX]; /* index db filename */

char dbn[PATH_MAX]; /* keyword db filename */

DB *idx; /* index recno database */

DB *db; /* keyword btree database */

};

/* Stack of temporarily unused index records. */

struct recs {

recno_t *stack; /* pointer to a malloc'ed array */

size_t size; /* number of allocated slots */

size_t cur; /* current number of empty records */

recno_t last; /* last record number in the index */

};

/* Tiny list for files. No need to bring in QUEUE. */

struct of {

Line 77 struct buf {

Line 104 struct buf {

/* Operation we're going to perform. */

enum op {

OP_NEW = 0, /* new database */

OP_DEFAULT = 0, /* new dbs from dir list or default config */

OP_CONFFILE, /* new databases from custom config file */

OP_UPDATE, /* delete/add entries in existing database */

OP_DELETE /* delete entries from existing database */

OP_DELETE, /* delete entries from existing database */

OP_TEST /* change no databases, report potential problems */

};

#define MAN_ARGS DB *hash, \

Line 102 static void hash_put(DB *, const struct buf *, uint

Line 131 static void hash_put(DB *, const struct buf *, uint

static void hash_reset(DB **);

static void index_merge(const struct of *, struct mparse *,

struct buf *, struct buf *, DB *,

DB *, const char *, DB *, const char *,

struct mdb *, struct recs *);

recno_t, const recno_t *, size_t);

static void index_prune(const struct of *, struct mdb *,

static void index_prune(const struct of *, DB *,

struct recs *);

const char *, DB *, const char *,

static void ofile_argbuild(int, char *[], struct of **,

recno_t *, recno_t **, size_t *,

const char *);

size_t *);

static void ofile_argbuild(int, char *[], struct of **);

static void ofile_dirbuild(const char *, const char *,

const char *, int, struct of **);

static void ofile_free(struct of *);

static void pformatted(DB *, struct buf *, struct buf *,

static void pformatted(DB *, struct buf *,

const struct of *);

struct buf *, const struct of *);

static int pman_node(MAN_ARGS);

static void pmdoc_node(MDOC_ARGS);

static int pmdoc_head(MDOC_ARGS);

Line 126 static int pmdoc_Nm(MDOC_ARGS);

Line 153 static int pmdoc_Nm(MDOC_ARGS);

static int pmdoc_Sh(MDOC_ARGS);

static int pmdoc_St(MDOC_ARGS);

static int pmdoc_Xr(MDOC_ARGS);

static void usage(void);

#define MDOCF_CHILD 0x01 /* Automatically index child nodes. */

Line 262 static const struct mdoc_handler mdocs[MDOC_MAX] = {

Line 288 static const struct mdoc_handler mdocs[MDOC_MAX] = {

};

static const char *progname;

static int mparse_options; /* abort the parse early */

static int use_all; /* Use all directories and files. */

static int verb; /* Output verbosity level. */

static int warnings; /* Potential problems in manuals. */

int

main(int argc, char *argv[])

{

struct mparse *mp; /* parse sequence */

struct manpaths dirs;

struct mdb mdb;

struct recs recs;

enum op op; /* current operation */

const char *dir;

char *conf_file;

char *cp;

char pbuf[PATH_MAX],

char pbuf[PATH_MAX];

ibuf[MAXPATHLEN], /* index fname */

fbuf[MAXPATHLEN]; /* btree fname */

int ch, i, flags;

DB *idx, /* index database */

DB *hash; /* temporary keyword hashtable */

*db, /* keyword database */

*hash; /* temporary keyword hashtable */

BTREEINFO info; /* btree configuration */

recno_t maxrec; /* last record number in the index */

size_t sz1, sz2, ipath;

recno_t *recs; /* the numbers of all empty records */

size_t sz1, sz2,

recsz, /* number of allocated slots in recs */

reccur; /* current number of empty records */

struct buf buf, /* keyword buffer */

dbuf; /* description buffer */

struct of *of; /* list of files for processing */

Line 300 main(int argc, char *argv[])

Line 321 main(int argc, char *argv[])

++progname;

memset(&dirs, 0, sizeof(struct manpaths));

memset(&mdb, 0, sizeof(struct mdb));

memset(&recs, 0, sizeof(struct recs));

verb = 0;

use_all = 0;

of = NULL;

db = idx = NULL;

mp = NULL;

hash = NULL;

recs = NULL;

op = OP_DEFAULT;

recsz = reccur = 0;

maxrec = 0;

op = OP_NEW;

dir = NULL;

conf_file = NULL;

mparse_options = MPARSE_SO;

while (-1 != (ch = getopt(argc, argv, "aC:d:u:v")))

while (-1 != (ch = getopt(argc, argv, "aC:d:Qtu:vW")))

switch (ch) {

case ('a'):

use_all = 1;

break;

case ('C'):

conf_file = optarg;

if (op) {

fprintf(stderr,

"-C: conflicting options\n");

goto usage;

}

dir = optarg;

op = OP_CONFFILE;

break;

case ('d'):

if (op) {

fprintf(stderr,

"-d: conflicting options\n");

goto usage;

}

dir = optarg;

op = OP_UPDATE;

break;

case ('Q'):

mparse_options |= MPARSE_QUICK;

break;

case ('t'):

dup2(STDOUT_FILENO, STDERR_FILENO);

if (op) {

fprintf(stderr,

"-t: conflicting options\n");

goto usage;

}

op = OP_TEST;

use_all = 1;

warnings = 1;

break;

case ('u'):

if (op) {

fprintf(stderr,

"-u: conflicting options\n");

goto usage;

}

dir = optarg;

op = OP_DELETE;

break;

case ('v'):

verb++;

break;

case ('W'):

warnings = 1;

break;

default:

usage();

goto usage;

return((int)MANDOCLEVEL_BADARG);

}

argc -= optind;

argv += optind;

if (OP_CONFFILE == op && argc > 0) {

fprintf(stderr, "-C: too many arguments\n");

goto usage;

}

memset(&info, 0, sizeof(BTREEINFO));

info.lorder = 4321;

info.flags = R_DUP;

mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);

mp = mparse_alloc(mparse_options, MANDOCLEVEL_FATAL, NULL, NULL);

memset(&buf, 0, sizeof(struct buf));

memset(&dbuf, 0, sizeof(struct buf));

Line 354 main(int argc, char *argv[])

Line 409 main(int argc, char *argv[])

buf.cp = mandoc_malloc(buf.size);

dbuf.cp = mandoc_malloc(dbuf.size);

flags = OP_NEW == op ? O_CREAT|O_TRUNC|O_RDWR : O_CREAT|O_RDWR;

if (OP_TEST == op) {

ofile_argbuild(argc, argv, &of, NULL);

if (NULL == of)

goto out;

index_merge(of, mp, &dbuf, &buf, hash, &mdb, &recs);

goto out;

}

if (OP_UPDATE == op || OP_DELETE == op) {

ibuf[0] = fbuf[0] = '\0';

if (NULL == realpath(dir, pbuf)) {

perror(dir);

exit((int)MANDOCLEVEL_BADARG);

}

if (strlcat(pbuf, "/", PATH_MAX) >= PATH_MAX) {

fprintf(stderr, "%s: path too long\n", pbuf);

exit((int)MANDOCLEVEL_BADARG);

}

strlcat(fbuf, dir, MAXPATHLEN);

strlcat(mdb.dbn, pbuf, PATH_MAX);

strlcat(fbuf, "/", MAXPATHLEN);

sz1 = strlcat(mdb.dbn, MANDOC_DB, PATH_MAX);

sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);

strlcat(ibuf, dir, MAXPATHLEN);

strlcat(mdb.idxn, pbuf, PATH_MAX);

strlcat(ibuf, "/", MAXPATHLEN);

sz2 = strlcat(mdb.idxn, MANDOC_IDX, PATH_MAX);

sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);

if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {

if (sz1 >= PATH_MAX || sz2 >= PATH_MAX) {

fprintf(stderr, "%s: Path too long\n", dir);

fprintf(stderr, "%s: path too long\n", mdb.idxn);

exit((int)MANDOCLEVEL_BADARG);

}

db = dbopen(fbuf, flags, 0644, DB_BTREE, &info);

flags = O_CREAT | O_RDWR;

idx = dbopen(ibuf, flags, 0644, DB_RECNO, NULL);

mdb.db = dbopen(mdb.dbn, flags, 0644, DB_BTREE, &info);

mdb.idx = dbopen(mdb.idxn, flags, 0644, DB_RECNO, NULL);

if (NULL == db) {

if (NULL == mdb.db) {

perror(fbuf);

perror(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

} else if (NULL == idx) {

} else if (NULL == mdb.idx) {

perror(ibuf);

perror(mdb.idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

ofile_argbuild(argc, argv, &of);

ofile_argbuild(argc, argv, &of, pbuf);

if (NULL == of)

goto out;

of = of->first;

index_prune(of, &mdb, &recs);

index_prune(of, db, fbuf, idx, ibuf,

&maxrec, &recs, &recsz, &reccur);

* Go to the root of the respective manual tree.

* This must work or no manuals may be found (they're

Line 405 main(int argc, char *argv[])

Line 469 main(int argc, char *argv[])

exit((int)MANDOCLEVEL_SYSERR);

}

index_merge(of, mp, &dbuf, &buf, hash,

db, fbuf, idx, ibuf,

&mdb, &recs);

maxrec, recs, reccur);

}

goto out;

Line 429 main(int argc, char *argv[])

Line 492 main(int argc, char *argv[])

dirs.paths[i] = mandoc_strdup(cp);

}

} else

manpath_parse(&dirs, conf_file, NULL, NULL);

manpath_parse(&dirs, dir, NULL, NULL);

for (i = 0; i < dirs.sz; i++) {

for (ipath = 0; ipath < dirs.sz; ipath++) {

ibuf[0] = fbuf[0] = '\0';

strlcat(fbuf, dirs.paths[i], MAXPATHLEN);

strlcat(fbuf, "/", MAXPATHLEN);

* Go to the root of the respective manual tree.

sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);

* This must work or no manuals may be found:

* They are indexed relative to the root.

strlcat(ibuf, dirs.paths[i], MAXPATHLEN);

if (-1 == chdir(dirs.paths[ipath])) {

strlcat(ibuf, "/", MAXPATHLEN);

perror(dirs.paths[ipath]);

sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);

exit((int)MANDOCLEVEL_SYSERR);

if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {

fprintf(stderr, "%s: Path too long\n",

dirs.paths[i]);

exit((int)MANDOCLEVEL_BADARG);

}

if (db)

/* Create a new database in two temporary files. */

(*db->close)(db);

if (idx)

(*idx->close)(idx);

db = dbopen(fbuf, flags, 0644, DB_BTREE, &info);

flags = O_CREAT | O_EXCL | O_RDWR;

idx = dbopen(ibuf, flags, 0644, DB_RECNO, NULL);

while (NULL == mdb.db) {

strlcpy(mdb.dbn, MANDOC_DB, PATH_MAX);

if (NULL == db) {

strlcat(mdb.dbn, ".XXXXXXXXXX", PATH_MAX);

perror(fbuf);

if (NULL == mktemp(mdb.dbn)) {

exit((int)MANDOCLEVEL_SYSERR);

perror(mdb.dbn);

} else if (NULL == idx) {

exit((int)MANDOCLEVEL_SYSERR);

perror(ibuf);

}

exit((int)MANDOCLEVEL_SYSERR);

mdb.db = dbopen(mdb.dbn, flags, 0644,

DB_BTREE, &info);

if (NULL == mdb.db && EEXIST != errno) {

perror(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

}

while (NULL == mdb.idx) {

strlcpy(mdb.idxn, MANDOC_IDX, PATH_MAX);

strlcat(mdb.idxn, ".XXXXXXXXXX", PATH_MAX);

if (NULL == mktemp(mdb.idxn)) {

perror(mdb.idxn);

unlink(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

}

mdb.idx = dbopen(mdb.idxn, flags, 0644,

DB_RECNO, NULL);

if (NULL == mdb.idx && EEXIST != errno) {

perror(mdb.idxn);

unlink(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

}

ofile_free(of);

of = NULL;

* Search for manuals and fill the new database.

if (-1 == chdir(dirs.paths[i])) {

ofile_dirbuild(".", "", "", 0, &of);

perror(dirs.paths[i]);

exit((int)MANDOCLEVEL_SYSERR);

}

ofile_dirbuild(".", NULL, NULL, 0, &of);

if (NULL != of) {

index_merge(of, mp, &dbuf, &buf, hash,

&mdb, &recs);

ofile_free(of);

of = NULL;

}

if (NULL == of)

(*mdb.db->close)(mdb.db);

continue;

(*mdb.idx->close)(mdb.idx);

mdb.db = NULL;

mdb.idx = NULL;

of = of->first;

* Go to the root of the respective manual tree.

* Replace the old database with the new one.

* This must work or no manuals may be found (they're

* This is not perfectly atomic,

* indexed relative to the root).

* but i cannot think of a better way.

if (-1 == chdir(dirs.paths[i])) {

if (-1 == rename(mdb.dbn, MANDOC_DB)) {

perror(dirs.paths[i]);

perror(MANDOC_DB);

unlink(mdb.dbn);

unlink(mdb.idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

if (-1 == rename(mdb.idxn, MANDOC_IDX)) {

index_merge(of, mp, &dbuf, &buf, hash, db, fbuf,

perror(MANDOC_IDX);

idx, ibuf, maxrec, recs, reccur);

unlink(MANDOC_DB);

unlink(MANDOC_IDX);

unlink(mdb.idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

out:

if (db)

if (mdb.db)

(*db->close)(db);

(*mdb.db->close)(mdb.db);

if (idx)

if (mdb.idx)

(*idx->close)(idx);

(*mdb.idx->close)(mdb.idx);

if (hash)

(*hash->close)(hash);

if (mp)

Line 508 out:

Line 594 out:

ofile_free(of);

free(buf.cp);

free(dbuf.cp);

free(recs);

free(recs.stack);

return(MANDOCLEVEL_OK);

usage:

fprintf(stderr,

"usage: %s [-aQvvv] [-C file] | dir ... | -t file ...\n"

" -d dir [file ...] | "

"-u dir [file ...]\n",

progname);

return((int)MANDOCLEVEL_BADARG);

}

void

index_merge(const struct of *of, struct mparse *mp,

struct buf *dbuf, struct buf *buf, DB *hash,

DB *db, const char *dbf, DB *idx, const char *idxf,

struct mdb *mdb, struct recs *recs)

recno_t maxrec, const recno_t *recs, size_t reccur)

{

recno_t rec;

int ch;

int ch, skip;

DBT key, val;

DB *files; /* temporary file name table */

struct mdoc *mdoc;

struct man *man;

const char *fn, *msec, *mtitle, *arch;

const char *fn, *msec, *march, *mtitle;

char *p;

uint64_t mask;

size_t sv;

unsigned seq;

struct db_val vbuf;

uint64_t vbuf[2];

char type;

for (rec = 0; of; of = of->next) {

static char emptystring[] = "";

if (warnings) {

files = NULL;

hash_reset(&files);

}

rec = 0;

for (of = of->first; of; of = of->next) {

fn = of->fname;

Line 551 index_merge(const struct of *of, struct mparse *mp,

Line 655 index_merge(const struct of *of, struct mparse *mp,

if (NULL != mdoc) {

msec = mdoc_meta(mdoc)->msec;

arch = mdoc_meta(mdoc)->arch;

march = mdoc_meta(mdoc)->arch;

if (NULL == march)

march = "";

mtitle = mdoc_meta(mdoc)->title;

} else if (NULL != man) {

msec = man_meta(man)->msec;

arch = NULL;

march = "";

mtitle = man_meta(man)->title;

} else {

msec = of->sec;

arch = of->arch;

march = of->arch;

mtitle = of->title;

}

* By default, skip a file if the manual section

* Check whether the manual section given in a file

* and architecture given in the file disagree

* agrees with the directory where the file is located.

* with the directory where the file is located.

* Some manuals have suffixes like (3p) on their

* section number either inside the file or in the

* directory name, some are linked into more than one

* section, like encrypt(1) = makekey(8). Do not skip

* manuals for such reasons.

if (0 == use_all) {

skip = 0;

assert(of->sec);

assert(msec);

if (warnings)

if (strcasecmp(msec, of->sec))

continue;

fprintf(stderr, "%s: "

"section \"%s\" manual "

"in \"%s\" directory\n",

fn, msec, of->sec);

if (NULL == arch) {

if (NULL != of->arch)

* Manual page directories exist for each kernel

continue;

* architecture as returned by machine(1).

} else if (NULL == of->arch ||

* However, many manuals only depend on the

strcasecmp(arch, of->arch))

* application architecture as returned by arch(1).

continue;

* For example, some (2/ARM) manuals are shared

}

* across the "armish" and "zaurus" kernel

* architectures.

* A few manuals are even shared across completely

* different architectures, for example fdformat(1)

* on amd64, i386, sparc, and sparc64.

* Thus, warn about architecture mismatches,

* but don't skip manuals for this reason.

if (NULL == arch)

assert(of->arch);

arch = "";

assert(march);

if (warnings)

if (strcasecmp(march, of->arch))

fprintf(stderr, "%s: "

"architecture \"%s\" manual "

"in \"%s\" directory\n",

fn, march, of->arch);

* By default, skip a file if the title given

* in the file disagrees with the file name.

* If both agree, use the file name as the title,

* Do not warn, this happens for all MLINKs.

* because the one in the file usually is all caps.

assert(of->title);

assert(mtitle);

if (strcasecmp(mtitle, of->title))

skip = 1;

if (0 == strcasecmp(mtitle, of->title))

mtitle = of->title;

* Build a title string for the file. If it matches

else if (0 == use_all)

* the location of the file, remember the title as

* found; else, remember it as missing.

if (warnings) {

buf->len = 0;

buf_appendb(buf, mtitle, strlen(mtitle));

buf_appendb(buf, "(", 1);

buf_appendb(buf, msec, strlen(msec));

if ('\0' != *march) {

buf_appendb(buf, "/", 1);

buf_appendb(buf, march, strlen(march));

}

buf_appendb(buf, ")", 2);

for (p = buf->cp; '\0' != *p; p++)

*p = tolower((unsigned char)*p);

key.data = buf->cp;

key.size = buf->len;

val.data = NULL;

val.size = 0;

if (0 == skip)

val.data = emptystring;

else {

ch = (*files->get)(files, &key, &val, 0);

if (ch < 0) {

perror("hash");

exit((int)MANDOCLEVEL_SYSERR);

} else if (ch > 0) {

val.data = (void *)fn;

val.size = strlen(fn) + 1;

} else

val.data = NULL;

}

if (NULL != val.data &&

(*files->put)(files, &key, &val, 0) < 0) {

perror("hash");

exit((int)MANDOCLEVEL_SYSERR);

}

if (skip && !use_all)

continue;

* The index record value consists of a nil-terminated

* filename, a nil-terminated manual section, and a

* nil-terminated description. Since the description

* nil-terminated description. Use the actual

* may not be set, we set a sentinel to see if we're

* location of the file, such that the user can find

* going to write a nil byte in its place.

* it with man(1). Since the description may not be

* set, we set a sentinel to see if we're going to

* write a nil byte in its place.

dbuf->len = 0;

type = mdoc ? 'd' : (man ? 'a' : 'c');

buf_appendb(dbuf, &type, 1);

buf_appendb(dbuf, fn, strlen(fn) + 1);

buf_appendb(dbuf, msec, strlen(msec) + 1);

buf_appendb(dbuf, of->sec, strlen(of->sec) + 1);

buf_appendb(dbuf, mtitle, strlen(mtitle) + 1);

buf_appendb(dbuf, of->title, strlen(of->title) + 1);

buf_appendb(dbuf, arch, strlen(arch) + 1);

buf_appendb(dbuf, of->arch, strlen(of->arch) + 1);

sv = dbuf->len;

Line 633 index_merge(const struct of *of, struct mparse *mp,

Line 803 index_merge(const struct of *of, struct mparse *mp,

else

pformatted(hash, buf, dbuf, of);

/* Test mode, do not access any database. */

if (NULL == mdb->db || NULL == mdb->idx)

continue;

* Make sure the file name is always registered

* as an .Nm search key.

buf->len = 0;

buf_append(buf, of->title);

hash_put(hash, buf, TYPE_Nm);

* Reclaim an empty index record, if available.

* Use its record number for all new btree nodes.

if (reccur > 0) {

if (recs->cur > 0) {

--reccur;

recs->cur--;

rec = recs[(int)reccur];

rec = recs->stack[(int)recs->cur];

} else if (maxrec > 0) {

} else if (recs->last > 0) {

rec = maxrec;

rec = recs->last;

maxrec = 0;

recs->last = 0;

} else

rec++;

vbuf.rec = htobe32(rec);

vbuf[1] = htobe64(rec);

* Copy from the in-memory hashtable of pending

Line 658 index_merge(const struct of *of, struct mparse *mp,

Line 841 index_merge(const struct of *of, struct mparse *mp,

seq = R_NEXT;

assert(sizeof(uint64_t) == val.size);

memcpy(&mask, val.data, val.size);

vbuf.mask = htobe64(mask);

vbuf[0] = htobe64(mask);

val.size = sizeof(struct db_val);

val.size = sizeof(vbuf);

val.data = &vbuf;

dbt_put(db, dbf, &key, &val);

dbt_put(mdb->db, mdb->dbn, &key, &val);

}

if (ch < 0) {

perror("hash");

unlink(mdb->dbn);

unlink(mdb->idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

* Apply to the index. If we haven't had a description

* set, put an empty one in now.

Line 683 index_merge(const struct of *of, struct mparse *mp,

Line 868 index_merge(const struct of *of, struct mparse *mp,

val.size = dbuf->len;

if (verb)

printf("%s: Added index\n", fn);

printf("%s: adding to index\n", fn);

dbt_put(idx, idxf, &key, &val);

dbt_put(mdb->idx, mdb->idxn, &key, &val);

}

* Iterate the remembered file titles and check that

* all files can be found by their main title.

if (warnings) {

seq = R_FIRST;

while (0 == (*files->seq)(files, &key, &val, seq)) {

seq = R_NEXT;

if (val.size)

fprintf(stderr, "%s: probably "

"unreachable, title is %s\n",

(char *)val.data, (char *)key.data);

}

(*files->close)(files);

}

Line 696 index_merge(const struct of *of, struct mparse *mp,

Line 898 index_merge(const struct of *of, struct mparse *mp,

* in `idx' (zeroing its value size).

static void

index_prune(const struct of *ofile, DB *db, const char *dbf,

index_prune(const struct of *ofile, struct mdb *mdb, struct recs *recs)

DB *idx, const char *idxf, recno_t *maxrec,

recno_t **recs, size_t *recsz, size_t *reccur)

{

const struct of *of;

const char *fn;

struct db_val *vbuf;

uint64_t vbuf[2];

unsigned seq, sseq;

DBT key, val;

int ch;

*reccur = 0;

recs->cur = 0;

seq = R_FIRST;

while (0 == (ch = (*idx->seq)(idx, &key, &val, seq))) {

while (0 == (ch = (*mdb->idx->seq)(mdb->idx, &key, &val, seq))) {

seq = R_NEXT;

assert(sizeof(recno_t) == key.size);

memcpy(maxrec, key.data, key.size);

memcpy(&recs->last, key.data, key.size);

/* Deleted records are zero-sized. Skip them. */

Line 730 index_prune(const struct of *ofile, DB *db, const char

Line 930 index_prune(const struct of *ofile, DB *db, const char

if (NULL == memchr(fn, '\0', val.size - 1))

break;

* Search for the file in those we care about.

* XXX: build this into a tree. Too slow.

for (of = ofile; of; of = of->next)

for (of = ofile->first; of; of = of->next)

if (0 == strcmp(fn, of->fname))

break;

Line 748 index_prune(const struct of *ofile, DB *db, const char

Line 948 index_prune(const struct of *ofile, DB *db, const char

sseq = R_FIRST;

while (0 == (ch = (*db->seq)(db, &key, &val, sseq))) {

while (0 == (ch = (*mdb->db->seq)(mdb->db,

&key, &val, sseq))) {

sseq = R_NEXT;

if (sizeof(struct db_val) != val.size)

if (sizeof(vbuf) != val.size)

break;

vbuf = val.data;

memcpy(vbuf, val.data, val.size);

if (*maxrec != betoh32(vbuf->rec))

if (recs->last != betoh64(vbuf[1]))

continue;

if ((ch = (*db->del)(db, &key, R_CURSOR)) < 0)

if ((ch = (*mdb->db->del)(mdb->db,

&key, R_CURSOR)) < 0)

break;

}

if (ch < 0) {

perror(dbf);

perror(mdb->dbn);

exit((int)MANDOCLEVEL_SYSERR);

} else if (1 != ch) {

fprintf(stderr, "%s: Corrupt database\n", dbf);

fprintf(stderr, "%s: corrupt database\n",

mdb->dbn);

exit((int)MANDOCLEVEL_SYSERR);

}

if (verb)

printf("%s: Deleted index\n", fn);

printf("%s: deleting from index\n", fn);

val.size = 0;

ch = (*idx->put)(idx, &key, &val, R_CURSOR);

ch = (*mdb->idx->put)(mdb->idx, &key, &val, R_CURSOR);

if (ch < 0)

break;

cont:

if (*reccur >= *recsz) {

if (recs->cur >= recs->size) {

*recsz += MANDOC_SLOP;

recs->size += MANDOC_SLOP;

*recs = mandoc_realloc

recs->stack = mandoc_realloc(recs->stack,

(*recs, *recsz * sizeof(recno_t));

recs->size * sizeof(recno_t));

}

(*recs)[(int)*reccur] = *maxrec;

recs->stack[(int)recs->cur] = recs->last;

(*reccur)++;

recs->cur++;

}

if (ch < 0) {

perror(idxf);

perror(mdb->idxn);

exit((int)MANDOCLEVEL_SYSERR);

} else if (1 != ch) {

fprintf(stderr, "%s: Corrupt index\n", idxf);

fprintf(stderr, "%s: corrupt index\n", mdb->idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

(*maxrec)++;

recs->last++;

}

Line 1179 static int

Line 1382 static int

pman_node(MAN_ARGS)

{

const struct man_node *head, *body;

const char *start, *sv;

char *start, *sv, *title;

size_t sz;

size_t sz, titlesz;

if (NULL == n)

return(0);

Line 1203 pman_node(MAN_ARGS)

Line 1406 pman_node(MAN_ARGS)

NULL != (body = body->child) &&

MAN_TEXT == body->type) {

assert(body->string);

title = NULL;

start = sv = body->string;

titlesz = 0;

* Suck the entire NAME section into memory.

* Yes, we might run away.

* But too many manuals have big, spread-out

* NAME sections over many lines.

for ( ; NULL != body; body = body->next) {

if (MAN_TEXT != body->type)

break;

if (0 == (sz = strlen(body->string)))

continue;

title = mandoc_realloc

(title, titlesz + sz + 1);

memcpy(title + titlesz, body->string, sz);

titlesz += sz + 1;

title[(int)titlesz - 1] = ' ';

}

if (NULL == title)

return(0);

title = mandoc_realloc(title, titlesz + 1);

title[(int)titlesz] = '\0';

/* Skip leading space. */

sv = title;

while (isspace((unsigned char)*sv))

sv++;

if (0 == (sz = strlen(sv))) {

free(title);

return(0);

}

/* Erase trailing space. */

start = &sv[sz - 1];

while (start > sv && isspace((unsigned char)*start))

*start-- = '\0';

if (start == sv) {

free(title);

return(0);

}

start = sv;

* Go through a special heuristic dance here.

* This is why -man manuals are great!

Line 1242 pman_node(MAN_ARGS)

Line 1491 pman_node(MAN_ARGS)

if (sv == start) {

buf_append(buf, start);

free(title);

return(1);

}

while (' ' == *start)

while (isspace((unsigned char)*start))

start++;

if (0 == strncmp(start, "-", 1))

start += 1;

else if (0 == strncmp(start, "\\-\\-", 4))

start += 4;

else if (0 == strncmp(start, "\\-", 2))

start += 2;

else if (0 == strncmp(start, "\\(en", 4))

Line 1265 pman_node(MAN_ARGS)

Line 1517 pman_node(MAN_ARGS)

buf_appendb(buf, start, sz);

hash_put(hash, buf, TYPE_Nd);

free(title);

}

Line 1280 pman_node(MAN_ARGS)

Line 1533 pman_node(MAN_ARGS)

* By necessity, this involves rather crude guesswork.

static void

pformatted(DB *hash, struct buf *buf, struct buf *dbuf,

pformatted(DB *hash, struct buf *buf,

const struct of *of)

struct buf *dbuf, const struct of *of)

{

FILE *stream;

char *line, *p;

char *line, *p, *title;

size_t len, plen;

size_t len, plen, titlesz;

if (NULL == (stream = fopen(of->fname, "r"))) {

perror(of->fname);

if (warnings)

perror(of->fname);

return;

}

Line 1317 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1571 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

while (NULL != (line = fgetln(stream, &len)))

if ('\n' != *line && ' ' != *line)

break;

* Read up until the next section into a buffer.

* Strip the leading and trailing newline from each read line,

* appending a trailing space.

* Ignore empty (whitespace-only) lines.

titlesz = 0;

title = NULL;

while (NULL != (line = fgetln(stream, &len))) {

if (' ' != *line || '\n' != line[(int)len - 1])

break;

while (len > 0 && isspace((unsigned char)*line)) {

line++;

len--;

}

if (1 == len)

continue;

title = mandoc_realloc(title, titlesz + len);

memcpy(title + titlesz, line, len);

titlesz += len;

title[(int)titlesz - 1] = ' ';

}

* If no page content can be found, or the input line

* is already the next section header, or there is no

Line 1325 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1605 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

* description.

line = fgetln(stream, &len);

if (NULL == title || '\0' == *title) {

if (NULL == line || ' ' != *line || '\n' != line[(int)len - 1]) {

if (warnings)

fprintf(stderr, "%s: cannot find NAME section\n",

of->fname);

buf_appendb(dbuf, buf->cp, buf->size);

hash_put(hash, buf, TYPE_Nd);

fclose(stream);

free(title);

return;

}

line[(int)--len] = '\0';

title = mandoc_realloc(title, titlesz + 1);

title[(int)titlesz] = '\0';

* Skip to the first dash.

Line 1341 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1625 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

* bytes).

if (NULL != (p = strstr(line, "- "))) {

if (NULL != (p = strstr(title, "- "))) {

for (p += 2; ' ' == *p || '\b' == *p; p++)

/* Skip to next word. */ ;

} else

} else {

p = line;

if (warnings)

fprintf(stderr, "%s: no dash in title line\n",

if ((plen = strlen(p)) > 70) {

of->fname);

plen = 70;

p = title;

p[plen] = '\0';

}

plen = strlen(p);

/* Strip backspace-encoding from line. */

while (NULL != (line = memchr(p, '\b', plen))) {

Line 1369 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1654 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

buf_appendb(buf, p, plen + 1);

hash_put(hash, buf, TYPE_Nd);

fclose(stream);

free(title);

}

static void

ofile_argbuild(int argc, char *argv[], struct of **of)

ofile_argbuild(int argc, char *argv[], struct of **of,

const char *basedir)

{

char buf[MAXPATHLEN];

char buf[PATH_MAX];

char *sec, *arch, *title, *p;

char pbuf[PATH_MAX];

const char *sec, *arch, *title;

char *relpath, *p;

int i, src_form;

struct of *nof;

for (i = 0; i < argc; i++) {

if (NULL == (relpath = realpath(argv[i], pbuf))) {

perror(argv[i]);

continue;

}

if (NULL != basedir) {

if (strstr(pbuf, basedir) != pbuf) {

fprintf(stderr, "%s: file outside "

"base directory %s\n",

pbuf, basedir);

continue;

}

relpath = pbuf + strlen(basedir);

}

* Try to infer the manual section, architecture and

Line 1388 ofile_argbuild(int argc, char *argv[], struct of **of)

Line 1690 ofile_argbuild(int argc, char *argv[], struct of **of)

* cat<section>[/<arch>]/<title>.0

if (strlcpy(buf, argv[i], sizeof(buf)) >= sizeof(buf)) {

if (strlcpy(buf, relpath, sizeof(buf)) >= sizeof(buf)) {

fprintf(stderr, "%s: Path too long\n", argv[i]);

fprintf(stderr, "%s: path too long\n", relpath);

continue;

}

sec = arch = title = NULL;

sec = arch = title = "";

src_form = 0;

p = strrchr(buf, '\0');

while (p-- > buf) {

if (NULL == sec && '.' == *p) {

if ('\0' == *sec && '.' == *p) {

sec = p + 1;

*p = '\0';

if ('0' == *sec)

Line 1407 ofile_argbuild(int argc, char *argv[], struct of **of)

Line 1709 ofile_argbuild(int argc, char *argv[], struct of **of)

}

if ('/' != *p)

continue;

if (NULL == title) {

if ('\0' == *title) {

title = p + 1;

*p = '\0';

continue;

Line 1420 ofile_argbuild(int argc, char *argv[], struct of **of)

Line 1722 ofile_argbuild(int argc, char *argv[], struct of **of)

arch = p + 1;

break;

}

if (NULL == title)

if ('\0' == *title) {

if (warnings)

fprintf(stderr,

"%s: cannot deduce title "

"from filename\n",

relpath);

title = buf;

}

* Build the file structure.

nof = mandoc_calloc(1, sizeof(struct of));

nof->fname = mandoc_strdup(argv[i]);

nof->fname = mandoc_strdup(relpath);

if (NULL != sec)

nof->sec = mandoc_strdup(sec);

nof->arch = mandoc_strdup(arch);

if (NULL != arch)

nof->arch = mandoc_strdup(arch);

nof->title = mandoc_strdup(title);

nof->src_form = src_form;

Line 1463 static void

Line 1769 static void

ofile_dirbuild(const char *dir, const char* psec, const char *parch,

int p_src_form, struct of **of)

{

char buf[MAXPATHLEN];

char buf[PATH_MAX];

#if defined(__sun)

struct stat sb;

#endif

size_t sz;

DIR *d;

const char *fn, *sec, *arch;

Line 1473 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1782 ofile_dirbuild(const char *dir, const char* psec, cons

int src_form;

if (NULL == (d = opendir(dir))) {

perror(dir);

if (warnings)

exit((int)MANDOCLEVEL_SYSERR);

perror(dir);

return;

}

while (NULL != (dp = readdir(d))) {

Line 1485 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1795 ofile_dirbuild(const char *dir, const char* psec, cons

src_form = p_src_form;

#if defined(__sun)

stat(dp->d_name, &sb);

if (S_IFDIR & sb.st_mode) {

#else

if (DT_DIR == dp->d_type) {

#endif

sec = psec;

arch = parch;

Line 1495 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1810 ofile_dirbuild(const char *dir, const char* psec, cons

* cat<section>/[<arch>/]

if (NULL == sec) {

if ('\0' == *sec) {

if(0 == strncmp("man", fn, 3)) {

src_form |= MANDOC_SRC;

sec = fn + 3;

} else if (0 == strncmp("cat", fn, 3)) {

src_form |= MANDOC_FORM;

sec = fn + 3;

} else if (use_all)

} else {

sec = fn;

if (warnings) fprintf(stderr,

else

"%s/%s: bad section\n",

continue;

dir, fn);

} else if (NULL == arch && (use_all ||

if (use_all)

NULL == strchr(fn, '.')))

sec = fn;

else

continue;

}

} else if ('\0' == *arch) {

if (NULL != strchr(fn, '.')) {

if (warnings) fprintf(stderr,

"%s/%s: bad architecture\n",

dir, fn);

if (0 == use_all)

continue;

}

arch = fn;

else if (0 == use_all)

} else {

continue;

if (warnings) fprintf(stderr, "%s/%s: "

"excessive subdirectory\n", dir, fn);

if (0 == use_all)

continue;

}

buf[0] = '\0';

strlcat(buf, dir, MAXPATHLEN);

strlcat(buf, dir, PATH_MAX);

strlcat(buf, "/", MAXPATHLEN);

strlcat(buf, "/", PATH_MAX);

sz = strlcat(buf, fn, MAXPATHLEN);

sz = strlcat(buf, fn, PATH_MAX);

if (MAXPATHLEN <= sz) {

if (PATH_MAX <= sz) {

fprintf(stderr, "%s: Path too long\n", dir);

if (warnings) fprintf(stderr, "%s/%s: "

exit((int)MANDOCLEVEL_SYSERR);

"path too long\n", dir, fn);

continue;

}

ofile_dirbuild(buf, sec, arch, src_form, of);

continue;

}

if (DT_REG != dp->d_type ||

#if defined(__sun)

(NULL == psec && !use_all) ||

if (0 == S_IFREG & sb.st_mode) {

! strcmp(MANDOC_DB, fn) ||

#else

! strcmp(MANDOC_IDX, fn))

if (DT_REG != dp->d_type) {

#endif

if (warnings)

fprintf(stderr,

"%s/%s: not a regular file\n",

dir, fn);

continue;

}

if (!strcmp(MANDOC_DB, fn) || !strcmp(MANDOC_IDX, fn))

continue;

if ('\0' == *psec) {

if (warnings)

fprintf(stderr,

"%s/%s: file outside section\n",

dir, fn);

if (0 == use_all)

continue;

}

* By default, skip files where the file name suffix

Line 1538 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1886 ofile_dirbuild(const char *dir, const char* psec, cons

suffix = strrchr(fn, '.');

if (0 == use_all) {

if (NULL == suffix) {

if (NULL == suffix)

if (warnings)

fprintf(stderr,

"%s/%s: no filename suffix\n",

dir, fn);

if (0 == use_all)

continue;

if ((MANDOC_SRC & src_form &&

} else if ((MANDOC_SRC & src_form &&

strcmp(suffix + 1, psec)) ||

(MANDOC_FORM & src_form &&

strcmp(suffix + 1, "0")))

strcmp(suffix + 1, "0"))) {

continue;

if (warnings)

}

fprintf(stderr,

if (NULL != suffix) {

"%s/%s: wrong filename suffix\n",

dir, fn);

if (0 == use_all)

continue;

if ('0' == suffix[1])

src_form |= MANDOC_FORM;

else if ('1' <= suffix[1] && '9' >= suffix[1])

src_form |= MANDOC_SRC;

}

* Skip formatted manuals if a source version is

* available. Ignore the age: it is very unlikely

Line 1563 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1917 ofile_dirbuild(const char *dir, const char* psec, cons

* and in ports, old manuals get removed on update.

if (0 == use_all && MANDOC_FORM & src_form &&

NULL != psec) {

'\0' != *psec) {

buf[0] = '\0';

strlcat(buf, dir, MAXPATHLEN);

strlcat(buf, dir, PATH_MAX);

p = strrchr(buf, '/');

if (NULL != parch && NULL != p)

if ('\0' != *parch && NULL != p)

for (p--; p > buf; p--)

if ('/' == *p)

break;

Line 1577 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1931 ofile_dirbuild(const char *dir, const char* psec, cons

p++;

if (0 == strncmp("cat", p, 3))

memcpy(p, "man", 3);

strlcat(buf, "/", MAXPATHLEN);

strlcat(buf, "/", PATH_MAX);

sz = strlcat(buf, fn, MAXPATHLEN);

sz = strlcat(buf, fn, PATH_MAX);

if (sz >= MAXPATHLEN) {

if (sz >= PATH_MAX) {

fprintf(stderr, "%s: Path too long\n", buf);

if (warnings) fprintf(stderr,

"%s/%s: path too long\n",

dir, fn);

continue;

}

q = strrchr(buf, '.');

if (NULL != q && p < q++) {

*q = '\0';

sz = strlcat(buf, psec, MAXPATHLEN);

sz = strlcat(buf, psec, PATH_MAX);

if (sz >= MAXPATHLEN) {

if (sz >= PATH_MAX) {

fprintf(stderr,

if (warnings) fprintf(stderr,

"%s: Path too long\n", buf);

"%s/%s: path too long\n",

dir, fn);

continue;

}

if (0 == access(buf, R_OK))

Line 1597 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1954 ofile_dirbuild(const char *dir, const char* psec, cons

}

assert('.' == dir[0]);

assert('/' == dir[1]);

buf[0] = '\0';

strlcat(buf, dir + 2, MAXPATHLEN);

assert('.' == dir[0]);

strlcat(buf, "/", MAXPATHLEN);

if ('/' == dir[1]) {

sz = strlcat(buf, fn, MAXPATHLEN);

strlcat(buf, dir + 2, PATH_MAX);

if (sz >= MAXPATHLEN) {

strlcat(buf, "/", PATH_MAX);

fprintf(stderr, "%s: Path too long\n", dir);

}

sz = strlcat(buf, fn, PATH_MAX);

if (sz >= PATH_MAX) {

if (warnings) fprintf(stderr,

"%s/%s: path too long\n", dir, fn);

continue;

}

nof = mandoc_calloc(1, sizeof(struct of));

nof->fname = mandoc_strdup(buf);

if (NULL != psec)

nof->sec = mandoc_strdup(psec);

nof->arch = mandoc_strdup(parch);

if (NULL != parch)

nof->arch = mandoc_strdup(parch);

nof->src_form = src_form;

Line 1647 ofile_free(struct of *of)

Line 2004 ofile_free(struct of *of)

{

struct of *nof;

while (of) {

if (NULL != of)

of = of->first;

while (NULL != of) {

nof = of->next;

free(of->fname);

free(of->sec);

Line 1656 ofile_free(struct of *of)

Line 2016 ofile_free(struct of *of)

free(of);

of = nof;

}

static void

usage(void)

{

fprintf(stderr, "usage: %s [-v] "

"[-C file] |"

" dir ... |"

" -d dir [file ...] |"

" -u dir [file ...]\n", progname);

}

CVSweb