mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.7 and 1.15

version 1.7, 2011/11/13 00:53:13

version 1.15, 2011/11/27 23:11:37

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

Line 20

#endif

#include <sys/param.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <assert.h>

#include <dirent.h>

Line 38

Line 41

#include "man.h"

#include "mdoc.h"

#include "mandoc.h"

#include "mandocdb.h"

#include "manpath.h"

#define MANDOC_DB "mandoc.db"

#define MANDOC_IDX "mandoc.index"

#define MANDOC_BUFSZ BUFSIZ

#define MANDOC_SLOP 1024

/* Bit-fields. See mandocdb.8. */

#define MANDOC_SRC 0x1

#define MANDOC_FORM 0x2

#define TYPE_NAME 0x01

#define TYPE_FUNCTION 0x02

#define TYPE_UTILITY 0x04

#define TYPE_INCLUDES 0x08

#define TYPE_VARIABLE 0x10

#define TYPE_STANDARD 0x20

#define TYPE_AUTHOR 0x40

#define TYPE_CONFIG 0x80

#define TYPE_DESC 0x100

#define TYPE_XREF 0x200

#define TYPE_PATH 0x400

#define TYPE_ENV 0x800

#define TYPE_ERR 0x1000

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

struct of {

char *fname; /* heap-allocated */

char *sec;

char *arch;

char *title;

int src_form;

struct of *next; /* NULL for last one */

struct of *first; /* first in list */

};

Line 100 static void buf_append(struct buf *, const char *);

Line 94 static void buf_append(struct buf *, const char *);

static void buf_appendb(struct buf *,

const void *, size_t);

static void dbt_put(DB *, const char *, DBT *, DBT *);

static void hash_put(DB *, const struct buf *, int);

static void hash_put(DB *, const struct buf *, uint64_t);

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 *, int,

DB *, const char *, int, int,

recno_t, const recno_t *, size_t);

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

const char *, DB *, const char *,

int, recno_t *, recno_t **, size_t *);

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

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

static int ofile_dirbuild(const char *, int, struct of **);

struct of **);

static int ofile_dirbuild(const char *, const char *,

const char *, int, int, int,

struct of **);

static void ofile_free(struct of *);

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

const struct of *);

static int pman_node(MAN_ARGS);

static void pmdoc_node(MDOC_ARGS);

static void pmdoc_An(MDOC_ARGS);

Line 264 int

Line 263 int

main(int argc, char *argv[])

{

struct mparse *mp; /* parse sequence */

struct manpaths dirs;

enum op op; /* current operation */

const char *dir;

char ibuf[MAXPATHLEN], /* index fname */

fbuf[MAXPATHLEN]; /* btree fname */

int verb, /* output verbosity */

use_all, /* use all directories and files */

ch, i, flags;

DB *idx, /* index database */

*db, /* keyword database */

*hash; /* temporary keyword hashtable */

BTREEINFO info; /* btree configuration */

recno_t maxrec; /* supremum of all records */

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

recno_t *recs; /* buffer of empty records */

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

size_t sz1, sz2,

recsz, /* buffer size of recs */

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

reccur; /* valid number of recs */

reccur; /* current number of empty records */

struct buf buf, /* keyword buffer */

dbuf; /* description buffer */

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

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

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

else

++progname;

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

verb = 0;

use_all = 0;

of = NULL;

db = idx = NULL;

mp = NULL;

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

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

op = OP_NEW;

dir = NULL;

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

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

switch (ch) {

case ('a'):

use_all = 1;

break;

case ('d'):

dir = optarg;

op = OP_UPDATE;

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

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

if (NULL == db) {

perror(fbuf);

exit((int)MANDOCLEVEL_SYSERR);

} else if (NULL == db) {

} else if (NULL == idx) {

perror(ibuf);

exit((int)MANDOCLEVEL_SYSERR);

}

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

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

printf("%s: Opened\n", ibuf);

}

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

ofile_argbuild(argv, argc, use_all, verb, &of);

if (NULL == of)

goto out;

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

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

&maxrec, &recs, &recsz);

if (OP_UPDATE == op)

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

db, fbuf, idx, ibuf, verb,

db, fbuf, idx, ibuf, use_all,

maxrec, recs, reccur);

verb, maxrec, recs, reccur);

goto out;

}

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

* Configure the directories we're going to scan.

* If we have command-line arguments, use them.

* If not, we use man(1)'s method (see mandocdb.8).

if (argc > 0) {

dirs.paths = mandoc_malloc(argc * sizeof(char *));

dirs.sz = argc;

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

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

} else

manpath_parse(&dirs, NULL, NULL);

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

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

strlcat(fbuf, argv[i], MAXPATHLEN);

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

strlcat(fbuf, "/", MAXPATHLEN);

sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN);

strlcat(ibuf, argv[i], MAXPATHLEN);

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

strlcat(ibuf, "/", MAXPATHLEN);

sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);

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

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

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

dirs.paths[i]);

exit((int)MANDOCLEVEL_BADARG);

}

if (db)

(*db->close)(db);

if (idx)

(*idx->close)(idx);

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

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

if (NULL == db) {

perror(fbuf);

exit((int)MANDOCLEVEL_SYSERR);

} else if (NULL == db) {

} else if (NULL == idx) {

perror(ibuf);

exit((int)MANDOCLEVEL_SYSERR);

}

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

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

ofile_free(of);

of = NULL;

if ( ! ofile_dirbuild(argv[i], verb, &of))

if ( ! ofile_dirbuild(dirs.paths[i], NULL, NULL,

0, use_all, verb, &of))

exit((int)MANDOCLEVEL_SYSERR);

if (NULL == of)

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

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

of = of->first;

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

idx, ibuf, verb, maxrec, recs, reccur);

idx, ibuf, use_all, verb,

maxrec, recs, reccur);

}

out:

Line 444 out:

Line 473 out:

if (mp)

mparse_free(mp);

manpath_free(&dirs);

ofile_free(of);

free(buf.cp);

free(dbuf.cp);

Line 455 out:

Line 485 out:

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, int verb,

DB *idx, const char *idxf, int use_all, int verb,

recno_t maxrec, const recno_t *recs, size_t reccur)

{

recno_t rec;

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

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

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

size_t sv;

unsigned seq;

char vbuf[8];

struct db_val vbuf;

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

fn = of->fname;

* Reclaim an empty index record, if available.

if (reccur > 0) {

--reccur;

rec = recs[(int)reccur];

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

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

mparse_reset(mp);

hash_reset(&hash);

mdoc = NULL;

man = NULL;

if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL) {

fprintf(stderr, "%s: Parse failure\n", fn);

* Try interpreting the file as mdoc(7) or man(7)

continue;

* source code, unless it is already known to be

* formatted. Fall back to formatted mode.

if ((MANDOC_SRC & of->src_form ||

! (MANDOC_FORM & of->src_form)) &&

MANDOCLEVEL_FATAL > mparse_readfd(mp, -1, fn))

mparse_result(mp, &mdoc, &man);

if (NULL != mdoc) {

msec = mdoc_meta(mdoc)->msec;

arch = mdoc_meta(mdoc)->arch;

mtitle = mdoc_meta(mdoc)->title;

} else if (NULL != man) {

msec = man_meta(man)->msec;

arch = NULL;

mtitle = man_meta(man)->title;

} else {

msec = of->sec;

arch = of->arch;

mtitle = of->title;

}

mparse_result(mp, &mdoc, &man);

if (NULL == mdoc && NULL == man)

* By default, skip a file if the manual section

continue;

* and architecture given in the file disagree

* with the directory where the file is located.

msec = NULL != mdoc ?

if (0 == use_all) {

mdoc_meta(mdoc)->msec : man_meta(man)->msec;

assert(of->sec);

mtitle = NULL != mdoc ?

assert(msec);

mdoc_meta(mdoc)->title : man_meta(man)->title;

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

arch = NULL != mdoc ?

continue;

mdoc_meta(mdoc)->arch : NULL;

if (NULL == arch) {

if (NULL != of->arch)

continue;

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

strcmp(arch, of->arch))

continue;

}

if (NULL == arch)

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,

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

assert(of->title);

assert(mtitle);

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

mtitle = of->title;

else if (0 == 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

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

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

dbuf->len = 0;

buf_append(dbuf, mdoc ? "mdoc" : (man ? "man" : "cat"));

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

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

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

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

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

if (mdoc)

pmdoc_node(hash, buf, dbuf,

mdoc_node(mdoc), mdoc_meta(mdoc));

else

else if (man)

pman_node(hash, buf, dbuf, man_node(man));

else

pformatted(hash, buf, dbuf, of);

* Copy from the in-memory hashtable of pending keywords

* into the database.

memset(vbuf, 0, sizeof(uint32_t));

memcpy(vbuf + 4, &rec, sizeof(uint32_t));

vbuf.rec = rec;

seq = R_FIRST;

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

seq = R_NEXT;

memcpy(vbuf, val.data, sizeof(uint32_t));

vbuf.mask = *(uint64_t *)val.data;

val.size = sizeof(vbuf);

val.size = sizeof(struct db_val);

val.data = vbuf;

val.data = &vbuf;

if (verb > 1)

printf("%s: Added keyword: %s\n",

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

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

{

const struct of *of;

const char *fn;

struct db_val *vbuf;

unsigned seq, sseq;

DBT key, val;

size_t reccur;

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

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

sseq = R_FIRST;

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

sseq = R_NEXT;

assert(8 == val.size);

assert(sizeof(struct db_val) == val.size);

if (*maxrec != *(recno_t *)(val.data + 4))

vbuf = val.data;

if (*maxrec != vbuf->rec)

continue;

if (verb)

printf("%s: Deleted keyword: %s\n",

Line 728 pmdoc_An(MDOC_ARGS)

Line 812 pmdoc_An(MDOC_ARGS)

return;

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_AUTHOR);

hash_put(hash, buf, TYPE_An);

}

static void

Line 789 pmdoc_Fd(MDOC_ARGS)

Line 873 pmdoc_Fd(MDOC_ARGS)

buf_appendb(buf, start, (size_t)(end - start + 1));

buf_appendb(buf, "", 1);

hash_put(hash, buf, TYPE_INCLUDES);

hash_put(hash, buf, TYPE_In);

}

/* ARGSUSED */

Line 801 pmdoc_Cd(MDOC_ARGS)

Line 885 pmdoc_Cd(MDOC_ARGS)

return;

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_CONFIG);

hash_put(hash, buf, TYPE_Cd);

}

/* ARGSUSED */

Line 815 pmdoc_In(MDOC_ARGS)

Line 899 pmdoc_In(MDOC_ARGS)

return;

buf_append(buf, n->child->string);

hash_put(hash, buf, TYPE_INCLUDES);

hash_put(hash, buf, TYPE_In);

}

/* ARGSUSED */

Line 841 pmdoc_Fn(MDOC_ARGS)

Line 925 pmdoc_Fn(MDOC_ARGS)

cp++;

buf_append(buf, cp);

hash_put(hash, buf, TYPE_FUNCTION);

hash_put(hash, buf, TYPE_Fn);

}

/* ARGSUSED */

Line 855 pmdoc_St(MDOC_ARGS)

Line 939 pmdoc_St(MDOC_ARGS)

return;

buf_append(buf, n->child->string);

hash_put(hash, buf, TYPE_STANDARD);

hash_put(hash, buf, TYPE_St);

}

/* ARGSUSED */

Line 874 pmdoc_Xr(MDOC_ARGS)

Line 958 pmdoc_Xr(MDOC_ARGS)

} else

buf_appendb(buf, ".", 2);

hash_put(hash, buf, TYPE_XREF);

hash_put(hash, buf, TYPE_Xr);

}

/* ARGSUSED */

Line 911 pmdoc_Vt(MDOC_ARGS)

Line 995 pmdoc_Vt(MDOC_ARGS)

buf_appendb(buf, start, sz);

buf_appendb(buf, "", 1);

hash_put(hash, buf, TYPE_VARIABLE);

hash_put(hash, buf, TYPE_Va);

}

/* ARGSUSED */

Line 925 pmdoc_Fo(MDOC_ARGS)

Line 1009 pmdoc_Fo(MDOC_ARGS)

return;

buf_append(buf, n->child->string);

hash_put(hash, buf, TYPE_FUNCTION);

hash_put(hash, buf, TYPE_Fn);

}

Line 940 pmdoc_Nd(MDOC_ARGS)

Line 1024 pmdoc_Nd(MDOC_ARGS)

buf_appendmdoc(dbuf, n->child, 1);

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_DESC);

hash_put(hash, buf, TYPE_Nd);

}

/* ARGSUSED */

Line 952 pmdoc_Er(MDOC_ARGS)

Line 1036 pmdoc_Er(MDOC_ARGS)

return;

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_ERR);

hash_put(hash, buf, TYPE_Er);

}

/* ARGSUSED */

Line 964 pmdoc_Ev(MDOC_ARGS)

Line 1048 pmdoc_Ev(MDOC_ARGS)

return;

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_ENV);

hash_put(hash, buf, TYPE_Ev);

}

/* ARGSUSED */

Line 976 pmdoc_Pa(MDOC_ARGS)

Line 1060 pmdoc_Pa(MDOC_ARGS)

return;

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_PATH);

hash_put(hash, buf, TYPE_Pa);

}

/* ARGSUSED */

Line 986 pmdoc_Nm(MDOC_ARGS)

Line 1070 pmdoc_Nm(MDOC_ARGS)

if (SEC_NAME == n->sec) {

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_NAME);

hash_put(hash, buf, TYPE_Nm);

return;

} else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)

return;

Line 995 pmdoc_Nm(MDOC_ARGS)

Line 1079 pmdoc_Nm(MDOC_ARGS)

buf_append(buf, m->name);

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_UTILITY);

hash_put(hash, buf, TYPE_Nm);

}

static void

hash_put(DB *db, const struct buf *buf, int mask)

hash_put(DB *db, const struct buf *buf, uint64_t mask)

{

DBT key, val;

int rc;

Line 1014 hash_put(DB *db, const struct buf *buf, int mask)

Line 1098 hash_put(DB *db, const struct buf *buf, int mask)

perror("hash");

exit((int)MANDOCLEVEL_SYSERR);

} else if (0 == rc)

mask |= *(int *)val.data;

mask |= *(uint64_t *)val.data;

val.data = &mask;

val.size = sizeof(int);

val.size = sizeof(uint64_t);

if ((rc = (*db->put)(db, &key, &val, 0)) < 0) {

perror("hash");

Line 1125 pman_node(MAN_ARGS)

Line 1209 pman_node(MAN_ARGS)

buf_appendb(buf, start, sz);

buf_appendb(buf, "", 1);

hash_put(hash, buf, TYPE_NAME);

hash_put(hash, buf, TYPE_Nm);

if (' ' == start[(int)sz]) {

start += (int)sz + 1;

Line 1164 pman_node(MAN_ARGS)

Line 1248 pman_node(MAN_ARGS)

buf_appendb(dbuf, start, sz);

buf_appendb(buf, start, sz);

hash_put(hash, buf, TYPE_DESC);

hash_put(hash, buf, TYPE_Nd);

}

Line 1175 pman_node(MAN_ARGS)

Line 1259 pman_node(MAN_ARGS)

return(0);

}

* Parse a formatted manual page.

* By necessity, this involves rather crude guesswork.

static void

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

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

const struct of *of)

{

int i;

FILE *stream;

char *line, *p;

size_t len, plen;

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

perror(of->fname);

return;

}

* Always use the title derived from the filename up front,

* do not even try to find it in the file. This also makes

* sure we don't end up with an orphan index record, even if

* the file content turns out to be completely unintelligible.

buf->len = 0;

buf_append(buf, of->title);

hash_put(hash, buf, TYPE_Nm);

while (NULL != (line = fgetln(stream, &len)) && '\n' != *line)

/* Skip to first blank line. */ ;

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

('\n' == *line || ' ' == *line))

/* Skip to first section header. */ ;

* If no page content can be found,

* reuse the page title as the page description.

if (NULL == (line = fgetln(stream, &len))) {

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

hash_put(hash, buf, TYPE_Nd);

fclose(stream);

return;

}

fclose(stream);

* If there is a dash, skip to the text following it.

for (p = line, plen = len; plen; p++, plen--)

if ('-' == *p)

break;

for ( ; plen; p++, plen--)

if ('-' != *p && ' ' != *p && 8 != *p)

break;

if (0 == plen) {

p = line;

plen = len;

}

* Copy the rest of the line, but no more than 70 bytes.

if (70 < plen)

plen = 70;

p[plen-1] = '\0';

buf_appendb(dbuf, p, plen);

buf->len = 0;

buf_appendb(buf, p, plen);

hash_put(hash, buf, TYPE_Nd);

}

static void

ofile_argbuild(char *argv[], int argc, int use_all, int verb,

struct of **of)

{

char buf[MAXPATHLEN];

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

int i, src_form;

struct of *nof;

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

* Try to infer the manual section, architecture and

* page title from the path, assuming it looks like

* man*[/<arch>]/<title>.<section> or

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

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

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

continue;

}

sec = arch = title = NULL;

src_form = 0;

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

while (p-- > buf) {

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

sec = p + 1;

*p = '\0';

if ('0' == *sec)

src_form |= MANDOC_FORM;

else if ('1' <= *sec && '9' >= *sec)

src_form |= MANDOC_SRC;

continue;

}

if ('/' != *p)

continue;

if (NULL == title) {

title = p + 1;

*p = '\0';

continue;

}

if (strncmp("man", p + 1, 3)) {

src_form |= MANDOC_SRC;

arch = p + 1;

} else if (strncmp("cat", p + 1, 3)) {

src_form |= MANDOC_FORM;

arch = p + 1;

}

break;

}

if (NULL == title)

title = buf;

* Build the file structure.

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

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

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

if (NULL != sec)

nof->sec = mandoc_strdup(sec);

if (NULL != arch)

nof->arch = mandoc_strdup(arch);

nof->title = mandoc_strdup(title);

nof->src_form = src_form;

* Add the structure to the list.

if (verb > 2)

printf("%s: Scheduling\n", argv[i]);

if (NULL == *of) {

Line 1206 ofile_argbuild(char *argv[], int argc, int verb, struc

Line 1428 ofile_argbuild(char *argv[], int argc, int verb, struc

* Pass in a pointer to a NULL structure for the first invocation.

static int

ofile_dirbuild(const char *dir, int verb, struct of **of)

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

int p_src_form, int use_all, int verb, struct of **of)

{

char buf[MAXPATHLEN];

struct stat sb;

size_t sz;

DIR *d;

const char *fn;

const char *fn, *sec, *arch;

char *p, *q, *suffix;

struct of *nof;

struct dirent *dp;

int src_form;

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

perror(dir);

Line 1222 ofile_dirbuild(const char *dir, int verb, struct of **

Line 1448 ofile_dirbuild(const char *dir, int verb, struct of **

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

fn = dp->d_name;

if ('.' == *fn)

continue;

src_form = p_src_form;

if (DT_DIR == dp->d_type) {

if (0 == strcmp(".", fn))

sec = psec;

arch = parch;

* By default, only use directories called:

* man<section>/[<arch>/] or

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

if (NULL == 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)

sec = fn;

else

continue;

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

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

arch = fn;

else if (0 == use_all)

continue;

if (0 == strcmp("..", fn))

continue;

buf[0] = '\0';

strlcat(buf, dir, MAXPATHLEN);

strlcat(buf, "/", MAXPATHLEN);

sz = strlcat(buf, fn, MAXPATHLEN);

if (sz < MAXPATHLEN) {

if (MAXPATHLEN <= sz) {

if ( ! ofile_dirbuild(buf, verb, of))

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

return(0);

continue;

}

} else if (sz < MAXPATHLEN)

continue;

if (verb > 2)

printf("%s: Scanning\n", buf);

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

if ( ! ofile_dirbuild(buf, sec, arch,

return(0);

src_form, use_all, verb, of))

return(0);

}

if (DT_REG != dp->d_type)

if (DT_REG != dp->d_type ||

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

!strcmp(MANDOC_DB, fn) ||

!strcmp(MANDOC_IDX, fn))

continue;

if (0 == strcmp(MANDOC_DB, fn) ||

0 == strcmp(MANDOC_IDX, fn))

* By default, skip files where the file name suffix

continue;

* does not agree with the section directory

* they are located in.

suffix = strrchr(fn, '.');

if (0 == use_all) {

if (NULL == suffix)

continue;

if ((MANDOC_SRC & src_form &&

strcmp(suffix + 1, psec)) ||

(MANDOC_FORM & src_form &&

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

continue;

}

if (NULL != suffix) {

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

* that people install newer formatted base manuals

* when they used to have source manuals before,

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

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

NULL != psec) {

buf[0] = '\0';

strlcat(buf, dir, MAXPATHLEN);

p = strrchr(buf, '/');

if (NULL == p)

p = buf;

else

p++;

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

memcpy(p, "man", 3);

strlcat(buf, "/", MAXPATHLEN);

sz = strlcat(buf, fn, MAXPATHLEN);

if (sz >= MAXPATHLEN) {

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

continue;

}

q = strrchr(buf, '.');

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

*q = '\0';

sz = strlcat(buf, psec, MAXPATHLEN);

if (sz >= MAXPATHLEN) {

fprintf(stderr,

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

continue;

}

if (0 == stat(buf, &sb))

continue;

}

buf[0] = '\0';

strlcat(buf, dir, MAXPATHLEN);

strlcat(buf, "/", MAXPATHLEN);

sz = strlcat(buf, fn, MAXPATHLEN);

if (sz >= MAXPATHLEN) {

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

return(0);

continue;

}

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

nof->fname = mandoc_strdup(buf);

if (NULL != psec)

nof->sec = mandoc_strdup(psec);

if (NULL != parch)

nof->arch = mandoc_strdup(parch);

nof->src_form = src_form;

* Remember the file name without the extension,

* to be used as the page title in the database.

if (NULL != suffix)

*suffix = '\0';

nof->title = mandoc_strdup(fn);

* Add the structure to the list.

if (verb > 2)

printf("%s: Scheduling\n", buf);

if (NULL == *of) {

*of = nof;

(*of)->first = nof;

Line 1287 ofile_free(struct of *of)

Line 1620 ofile_free(struct of *of)

while (of) {

nof = of->next;

free(of->fname);

free(of->sec);

free(of->arch);

free(of->title);

free(of);

of = nof;

}

CVSweb